core java 10~12(多线程 & I/O & Network网络编程)

MODULE 10 Threads 多线程

--------------------------------

进程： 计算机在运行过程中的任务单元，CPU在一个时间点上只能执行一个进程，但在一个时间段上采用时间分片原则。

特点：

每个进程执行时需要独立的数据空间，独立分配内存，多个进程间的资源互不共享。因此进程是非常耗费资源的

线程：是程序运行时的最小执行单位

特点：

1）线程依赖于进程

2）一个进程可以分为多个线程 例：QQ

3）*多线程可以共享资源

多进程和多线程的设计目的都是为了在同时执行多个任务

多线程带来的问题：

多线程间的并发（互斥）与同步，（由共享资源引发的问题）

线程类Thread

创建自己的线程

1.继承Thread类

class MyThread extends Thread{

public void run(){

//线程处理代码

}

}

运用：

MyThread th1=new MyThread();

th1.run();//错误

th1.start();//启动该线程，执行的是run()方法中的代码

2.实现Runnable接口

class MyThread implements Runnable{

public void run(){

//线程处理代码

}

}

运用：

MyThread th1=new MyThread();

th1.start();//错误

Thread thread=new Thread(th1);

thread.start();//启动线程，执行的是th1中的run()方法

练习：

龟兔猫狗百米赛跑，要求：只要有一个先跑到终点，比赛结束

分析：设置一个多个线程都共享的数据

static boolean isRunning=true;

线程生命周期的状态：

1.Runnable就绪状态

new -->start() --> Runnable

等待JVM调度执行

2.Running状态

JVM采取时间分片策略，被调度的线程从Runnable进入Running状态

执行run()方法中的代码，一旦时间片结束，无论run()方法是否执行完，JVM都会收回该线程的执行权，调度其他处于Runnable状态的线程

Runnable <-----> Running

3.Dead死亡状态

run()方法执行结束

4.Blocked阻塞状态

1）sleep() ---> blocked

等到睡眠时间结束，该线程从bloced ---> Runnable,等待JVM重新调度

2）join() ---> blocked

调用另一线程的join()方法，使本线程进入阻塞状态，直到另一线程执行结束，本线程 blocked ---> Runnable

多线程的并发访问

----------------------------------

多个线程共享数据引发并发问题

练习：



如何解决并发访问？

synchronized关键字

1）寻找公有的对象，并在公有对象身上加锁，确保一次只能有一个线程操作该对象

synchronized(Object){

//只允许一个线程执行这部分代码

}

2）精确控制加锁的范围（或者说加锁的临界值），否则影响程序效率



线程如何从locked回到Runnable状态

------------------------------------

1）sleep 睡眠时间结束，回到Runnable

2）join() 等到另一线程执行结束，本线程回到Runnable

3）如何人为使线程从blocked ------> Runnable

a) interrupt()

人为使线程从blocked ------> Runnable

阻塞的线程一旦被调用interrupt()方法唤醒，会抛出InterruptedException,线程自己可以通过捕获该异常知道自己被中断

b)isInterrupted() 返回boolean类型，判断线程是否被中断

c)interrupted() 清除中断信息，因为一个线程被中断后会设置标志信息，isInterruped()判断为true,一旦调用interrupted()清除中断信息后，isInterruped()判断改为false

练习：ThreadState.java , 在主线程中监控另一个线程让该线程sleep后，调用interrupt()方法使其从blocked回到Runnable



线程同步问题

-------------------------------------

并发：是多个线程地位均等，共同竞争对公有对象的访问权，一次只能一个线程访问

同步：解决的是多个线程对公有对象访问的先后顺序问题

解决同步问题的思路：

1）找出公有对象，多个线程都通过公有对象进行通信

2）找出哪个线程该wait,哪个线程负责notify发通知

3）确保wait在notify之前

添加标志变量hasWait,等待的线程在调用wait()之前设置该变量，负责发通知的线程在notify()之前先判断该变量，确保notify时公有对象身上已经有wait的线程

练习：

定义一个线程CalculateThread,计算1~100的和，把结果放到一个对象中

定义一个线程PrintThread,从该对象中取出结果并打印输出

定义一个测试程序Test.java

分析：

1)属于同步问题

2)公有对象Result{int value;}

3)CalculateThread负责notify，PrintThread负责wait

注意点：

1.wait()和notify()要加synchronized

多个线程竞争公有对象res的访问锁，等待的线程间要互斥

2.等待的线程在wait之前要先设置标志变量，否则wait之后阻塞，无法设置

3.发通知的线程在notify之前要循环判定公有对象身上是否有等待的线程，有wait线程才发通知唤醒

4.while循环一定要放synchronized外面，否则拿着锁再sleep,其他线程永远拿不到res对象的访问权



setPriority() 设置线程的优先级 1~10级 优先级并不能决定线程的先后执行顺序，最终仍由JVM决定

Thread.yield() 将执行权让给优先级比自己高的线程

弃而不用的方法：

stop() / resume() / suspend()

这些方法被调用时，线程所占据的资源的锁不会被释放

死锁问题

------------------------------

若干线程去竞争有限的资源，要求同时拿到多个公有资源时，因公有资源数量有限，不能满足所有线程的需求，每个线程都只拿到部分资源且不释放，就造成死锁问题

哲学家就餐问题

如何解决?

让多个竞争资源的线程以相同的顺序去拿



MODULE 11 I/O 输入/输出

------------------------------------

java中采取流的概念， 在应用程序和外围设备之间建立一个流对象，确保无论外围设备是什么，应用程序只单一的通过访问流对象来读写数据

按流的方向，分为：

输入流InputStream

程序从输入流【读取】数据，但不能写入

read()...

输出流OutputStream

程序往输出流中【写入】数据，但不能读取

write()...

按照流的传输单位

字节流

以字节为基本传输单位，一个个字节传输

注意点：

1）流中的数据没有结构，例int数据4个字节，拆成4次传输

2）最终传输给外围设备的一定是字节流

通常以Stream结尾的都是字节流*

字符流

字节的可读性很差，字符流提供以文本的形式读写数据

通常带有Reader/Writer的都是字符流*

具有缓存功能的流

在流对象中设置缓存区，数据先放入缓存区，再一次性读写外围设备

目的：提高数据的传输性能

过滤器

对流中提供的数据进行进一步处理

字节流传输无结构，过滤器可以将字节流中的字节拼成应用程序需要的数据类型，如int double float...

*不能单独使用，一定要结合某个字节流

InputStream常见的方法

read() 每次返回一个字节，返回结果>=0为有效数据， -1表示流中数据读完

read(byte[]) 可以一次读取多个字节，放入byte[]数组中，返回一次读取成功的字节数

注意：

I/O流要与外围设备进行交互，所有资源都要手工回收

finally{

//添加资源回收代码

}

close（） 关闭流对象，释放内存资源

available() 判断流是否可用

flush() 程序强制将缓存区中的数据刷新到外围设备中

字节流的层级结构

-------------------------

通常InputStream/OutputStream 前面的代表了数据源或数据目的地类型

FileInputStream 把文件作为数据源，从文件中读数据

FileOutputStream 把文件作为数据目的地，往文件中写入数据

PipedInputStream 把管道作为数据源

PipedOutputStream 把管道作为数据目的地

过滤器 对字节流进一步包装

1）BufferedInputStream

具有缓存功能的流

2)PushbackInputStream

把从流中读取的数据退回去

3)DataInputStream

能够将字节流中的字节拼成程序需要的基本数据类型

readInt(0 readDouble()...

包: java.io;

异常: IOException



练习：创建类Copy.java实现文件的拷贝

将一个文件的内容拷贝到另一文件

分析：从源文件读入数据，FileInputStream read()

写入目标文件 FileOutputStream write()

改造：以提高性能的方式

例：以提高性能的方式从指定文件啊src.txt中读取含有基本数据类型的内容

分析:

DataInputStream dis=new DataInputStream(new BufferedInputStream(new FileInputStream("src.txt")));

练习：将一个int型整数写入文件中

1）将一个个字节传输，将int拆成4个字节

2）DataOutputStream(BufferedOutputStream(FileOutputStream))



管道流PipedInputStream/PipedOutputStream

-----------------------------------------------

PipedInputStream 从管道中读取数据

PipedOutputStream 往管道中写入数据

通过管道将输入流和输出流衔接起来

练习：

创建两个线程，通过管道流实现两个线程的数据传输

一个线程Sender负责产生100个随机数，并写入管道中

一个线程Fetcher负责从管道中读取数据，并打印输出

分析； class Sender extends Thread{

PipedOutputStream pos;

public void run(){}

}

class Fetcher extends Thread{

PipedInputStream pis;

public void run(){}

}



字符流Reader/Writer

------------------------------

字节流可读性差，字符流提供以文本形式传输数据

特别的流对象

1.BufferedrReader/BufferedWriter

1)开辟缓存区提高传输性能

类似BufferedInputStream(BIS)/BOS

2)提供字符流和字符串之间的转换

类似DIS/DOS

BufferedReader: readLine() 字符流--->字符串

BUfferedWriter: write(String,off,len) 字符串---->字符流

2.InputStreamReader/OutputStreamWriter 桥梁类

最终与外围设备交互的是字节流

1）提供字节流和字符流之间的转换

InputStreamReader:字节流-----> 字符流

OutputstreamWriter：字符流----> 字节流

2)提供java标准编码UTF8和其他编码之间的转换

3.FileReader/FileWriter 是InputStreamReader/OutputStreamWriter的子类

1)具有读写文件的功能

2)作为ISR/OSW的子类，也提供字节流和字符流之间的转换

3)将编码自动转换成操作系统对应的编码格式



练习：

将一个字符串写入文件中，再读取该文件并将内容输出到控制台

分析：

字符串 --->文件

字符串----> 字符流 BuffredWriter

字符流 字节流 OutputStreamWriter FileWriter

字节流 文件 FileOutputStream

文件-----> 控制台

System.out 标准输出

System.in 键盘

System.err 标准错误

对象序列化 ObjectInputStream/ObjectOutputStream

------------------------------------------------------------

序列化：将对象转化为字节流，通常用于保存对象 的当前状态信息

使对象持久化，以备将来对该对象进行恢复

反序列化：字节流-----> Object

ObjectInputStream: Object readObject(){} 反序列化

ObjectOutputStream: writeObject(Object) 序列化

序列化实现接口：

Serializable

class Company implements Serializable{

String name;

int tel;

transient Address add; //标注该属性信息无法序列化

}

class Address{

String city;

String street;

int no;

}

注意:

1）大对象中包含小对象，序列化时要求小对象也实现了序列化接口

2）对于不能序列化的属性，需要用transient修饰

练习：ObjectTest.java



RandomAccessFile随机访问文件

-----------------------------------

以随机访问的方式读写文件中任意一段内容

skip(long) 虽是跳步，但也是从头开始跳过若干字节再进行读写

功能：

1）实现了DataInput / DataOutput接口，类似过滤器

2）读/写功能都具有

readInt() writeInt()......

3)具有操作文件的功能

4）可以随意跳到文件的某个位置开始读写

构造器中的参数：

mode 指定读/写的模式

"r":只读 "r":只写 "rw"：读/写

seek(long) 跳过long 指定的若干字节数，开始读写



MODULE 12 Network网络编程

--------------------------------

ip地址 通过IP地址可以唯一定位到网络上的某台机器

port端口：人为制造的数字，代表一个服务器上某个应用的唯一标识

基于TCP/IP网络编程

传输控制协议，考虑的是传输的可靠性问题

基于UDP的网络编程

用户数据报文协议，考虑的是传输的效率问题

通讯双方满足的五要素：

1.通讯双方IP地址（两个）

2.通讯双方的PORT端口号（两个）

3.通讯双方要遵守同样的协议

java.net包：

Socket/SeverSocket:实现基于TCP/IP网络编程

DatagramSocket/DatagramPacket:为UDP协议服务

IP网络层

基本特点：

无连接的；数据可靠性不能保证的；

TCP 传输层

1）面向连接的

2）完全可靠的数据传输

3）点对点的

4）同一连接既可以发送也可以接收

5）面向字节流的

连接的简历经过了三次握手：

1）客户端发出连接请求

2）服务器回复确认

3）建立连接

Client：

构建Socket，连接指定的IP和port

---> 获取输入流/输出流

--> 对I/O流进行包装

---->读/写数据

-->释放资源（Socket/I/O）

Server:

构建SeverSocket,指定监听的端口号

--->接收客户端连接请求，获取Socket建立连接

----> 对I/O流进行包装

---->读/写数据

-->释放资源（sevrverSocket/Socket/I/O）



PrintWriter功能

String-->字节流

BufferedWriter 字符串-->字符流

OutputStreamWriter 字符流--->字节流

1.字符串--->字节流

兼具了BufferedWriter/OutputStreamWriter两者的功能

2.可以自动刷新

new PrintWriter(OS,true);

UDP 用户数据报文协议

-------------------------------------------

1）考虑的是数据传输的效率问题，可靠性不保证

2）不一定是一对一，而是多对多通讯，如广播

3）无连接的，不可靠的传输方式

DatagramSocket 负责数据的发送和接受 如邮递员

DatagramPacket 把数据打成报文对象，填入对方的IP地址和端口号 如信件

构造器：

DatagramPacket()