Java I/O模式（一）

第一章 Java的I/O演进之路

1.1 I/O模型基本说明

1/0模型：就是用什么样的通道或者说是通信模式和架构进行数据的传输和接收，很大程度上决定了程序通信的性能，Java 共支持3种网络编程的/10 模型：BIO、NIO、AIO

实际通信需求下，要根据不同的业务场景和性能需求決定选择不同的1/0模型

1.2 I/O 模型

Java BIO

同步并阻塞（传统阻塞型），服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就

需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销
请添加图片描述

Java NIO

同步非阻塞，服务器实现模式为一个线程处理多个请求（连接），即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到有I/O请求就进行处理。

请添加图片描述

Java AIO

异步非阻塞，服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是由OS先处理完成，再通知服务器去启动线程进行处理，一般适用于连接数较多且连接时间长的应用

1.3 BIO、NIO、AIO适用场景分析

I/O模型	适用场景
BIO	BIO 方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4以前的唯一选择，但程序简单易理解。
NIO	NIO 方式适用于连接数目多且连接比较短（轻操作）的架构，比如聊天服务器，弹幕系统，服务器间通讯等。编程比较复杂，JDK1.4 开始支持。
AIO	AIO 方式使用于连接数目多且连接比较长（重操作）的架构，比如相册服务器，充分调用 OS 参与并发操作，编程比较复杂，JDK7 开始支持。

第二章 JAVA BIO 深入剖析

2.1 Java BIO 基本介绍

Java BIO 就是传统的Java IO 编程，其相关的类和接口在java.io
同步并阻塞（传统阻塞型），服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，可以通过线程池机制改善（实现多个客户端连接服务器）

2.2 Java BIO 工作机制

请添加图片描述

2.2 Java BIO 样例

客户端

/**
 * 客户端 Client
 */

public class Client {
	public static void main(String[] args) throws IOException {
		// 1.创建一个socket对象
		Socket socket = new Socket("127.0.0.1",9999);
		// 2.从socket对象中获得字节输出流
		OutputStream outputStream = socket.getOutputStream();
		// 3.把字节输出流包装成一个打印流
		PrintStream printStream = new PrintStream(outputStream);
		printStream.print("hello World! 服务端");


		printStream.flush();
	}
}

服务端

/**
 * 目标: 客户端发消息,服务端接收消息
 */

public class Server {
	public static void main(String[] args) {
		try {

			System.out.println("=============原神 启动===============");
			// 1.定义一个 ServerSocket对象进行服务端的端口注册
			ServerSocket serverSocket = new ServerSocket(9999);

			// 2.监听客户端 Socket 链接请求
			Socket socket = serverSocket.accept();
			// 3.从socket管道中得到一个字节输入流对象
			InputStream inputStream = socket.getInputStream();
			// 4.把字节输入流包装成一个缓存字符输入流
			 BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
			String msg;
			if ((msg = bufferedReader.readLine()) != null){
				System.out.println("服务端接收到:"+msg);
			}

			// 把字节输入流包装成一个缓存字节输入流
			//BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);

		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

2.4 BIO模式下多发和多收消息【一对一】

/**
 * 客户端
 */

public class Client {
	public static void main(String[] args) throws IOException {
		// 1.创建一个socket对象
		Socket socket = new Socket("127.0.0.1",9999);
		// 2.从socket对象中获得字节输出流
		OutputStream outputStream = socket.getOutputStream();
		// 3.把字节输出流包装成一个打印流
		PrintStream printStream = new PrintStream(outputStream);

		Scanner scanner = new Scanner(System.in);

		while (true){
			System.out.println("请说");
			String msg = scanner.nextLine();
			printStream.println(msg);
			printStream.flush();
		}
    
	}
}

/**
 * 目标: 服务端反复接收消息,客户端反复发送消息
 */

public class Server {
	public static void main(String[] args) {
		try {

			System.out.println("=============原神 启动===============");
			// 1.定义一个 ServerSocket对象进行服务端的端口注册
			ServerSocket serverSocket = new ServerSocket(9999);

			// 2.监听客户端 Socket 链接请求
			Socket socket = serverSocket.accept();
			// 3.从socket管道中得到一个字节输入流对象
			InputStream inputStream = socket.getInputStream();
			// 4.把字节输入流包装成一个缓存字符输入流
			 BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
			String msg;
			 while ((msg = bufferedReader.readLine()) != null){
				System.out.println("服务端接收到:"+msg);
			}

			// 把字节输入流包装成一个缓存字节输入流
			//byte[] bytes = new byte[1024];
			//BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);
			//while (bufferedInputStream.read(bytes)>0){
			//	System.out.println("客户端收到了"+bytes.toString());
			//}

		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

2.5 BIO模式接收多个客户端

如果服务端需要处理很多个客户端的消息通信请求，此时我们就需要在服务端引入线程了，也就是说客户端每发起一个请求，服务端

就创建一个新的线程来处理这个客户端的请求，这样就实现了一个客户端一个线程的模型

/**
 * 目标: 服务端同时接收多个socket通信需求
 * 思路: 每收到一个socket请求后交给一个独立的线程来处理客户端的数据交互
 */

public class Server {
	public static void main(String[] args) {
		try {
			// 1.注册端口
			ServerSocket serverSocket = new ServerSocket(9999);
			// 2.定义一个死循环,负责不断的接收客户端的socket请求
			while (true){
				Socket socket = serverSocket.accept();
				// 3.创建一个独立线程处理这个客户端socket请求
				ServerThreadReader serverThreadReader = new ServerThreadReader(socket);
				serverThreadReader.start();
			}
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
	}
	
}

class ServerThreadReader extends Thread{
	private Socket socket;
	ServerThreadReader(Socket socket){
		this.socket = socket;
	}

	@Override
	public void run() {
		System.out.println("=============原神 启动===============");
		// 从 socket 对象中得到字节输入流
		InputStream inputStream = null;
		try {
			inputStream = socket.getInputStream();
			BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));

			String msg;
			while ((msg=bufferedReader.readLine())!=null){
				String name = Thread.currentThread().getName();
				System.out.println(name+msg);
			}
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
		
	}
}

小结

小结
1.每个Socket接收到，都会创建一个线程，线程的竞争、切换上下文影响性能；
2.每个线程都会占用栈空间和CPU资源；
3.并不是每个socket都进行I0操作，无意义的线程处理；
4.客户端的并发访问增加时。服务端将呈现1:1的线程开销，访问量越大，系统将发生线程栈溢出，线程创建失败，最终导致进程宕机或者僵死，从而不能对外提供服务。

2.6 伪异步 I/O 编程

在上述案例中：客户端的并发访问增加时。服务端将呈现1:1的线程开销，访问量越大，系统将发生线程栈溢出，线程创建失败，最终导致进程宕机或者僵死，从而不能对外提供服务。

接下来我们采用一个伪异步1/0的通信框架，采用线程池和任务队列实现，当客户端接入时，将客户端的Socket封装成一个Task（该任务实现java.lang.Runnable线程任务接口）交给后端的线程池中进行处理。JDK的线程池维护一个消息队列和N个活跃的线程，对消息队列中Socket任务进行处理，由于线程池可以设置消息队列的大小和最大线程数，因此，它的资源占用是可控的，无论多少个客户端并发访问，都不会导致资源的耗尽和宕机。

请添加图片描述

服务端代码

/**
 * 目标: 开发实现伪异步通信架构
 */
public class Server {
	public static void main(String[] args) {
		try {
			// 1.注册端口
			ServerSocket serverSocket = new ServerSocket(9999);
			// 2.初始化一个线程对象
			HandlerSocketServerPool handlerSocketServerPool = new HandlerSocketServerPool(3, 10);
			// 3.定义一个循环介绍客户端socket连接请求
			while (true){
				Socket socket = serverSocket.accept();
				//4.把socket对象封装成一个任务对象
				ServerRunnableTarget serverRunnableTarget = new ServerRunnableTarget(socket);
				// 4.把任务对象交给一个线程池进行处理
				handlerSocketServerPool.excute(serverRunnableTarget);

			}
		}catch(Exception e){
			e.printStackTrace();
		}

	}
}

/*------------------------------------------类分界线---------------------------------------------------*/

public class ServerRunnableTarget implements Runnable{
	private Socket socket;
	ServerRunnableTarget(Socket socket){
		this.socket = socket;
	}
	@Override
	public void run() {
		System.out.println("=============原神 启动===============");
		// 从 socket 对象中得到字节输入流
		InputStream inputStream = null;
		try {
			inputStream = socket.getInputStream();
			BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));

			String msg;
			while ((msg=bufferedReader.readLine())!=null){
				String name = Thread.currentThread().getName();
				System.out.println(name+msg);
			}
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
	}
}

/*------------------------------------------类分界线---------------------------------------------------*/

public class HandlerSocketServerPool {
	// 1.创建一个线程池的成员变量,用来存储一个线程池对象
	private ExecutorService executorService;

	/**
	 * 2.创建这个类的对象的时候需要初始化线程池对象
	 * @param maxThreadNum
	 * @param queueSize
	 */
	HandlerSocketServerPool(int maxThreadNum, int queueSize){
		executorService = new ThreadPoolExecutor(2,maxThreadNum,20,
				TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(queueSize));
	}

	/**
	 * 3.提供一个方法来提交任务给线程池的任务队列来暂存,等着线程来处理
	 */

	public void excute(Runnable target){
		executorService.execute(target);
	}
}

小结：

伪异步io采用了线程池实现，因此避免了为每个请求创建一个独立线程造成线程资源耗尽的问题，但由于底层依然是采用的同步阻塞模型，因此无法从根本上解决问题。
如果单个消息处理的缓慢，或者服务器线程池中的全部线程都被阻塞，那么后续socket的io消息都将在队列中排队。新的Socket请求将被拒绝，客户端会发生大量连接超时。

2.7 基于 BIO 形式下的文件上传

/**
 * 目标:服务端开发,实现可以接收服务端任意类型文件,并保存到服务端磁盘
 */
public class Server {
	public static void main(String[] args) {

		try {
			ServerSocket serverSocket = new ServerSocket(8888);
			while (true){
				Socket socket = serverSocket.accept();
				// 交给一个独立的线程来处理
				ServerReaderThread serverReaderThread = new ServerReaderThread(socket);
				serverReaderThread.start();
			}
		}catch (Exception e){
			e.printStackTrace();
		}
	}
}

/*------------------------------------------类分界线---------------------------------------------------*/


public class ServerReaderThread extends Thread{

	private Socket socket;
	public ServerReaderThread(Socket socket){
		this.socket = socket;
	}
	@Override
	public void run() {
		try {
			// 1.得到数据输入流得到客户端发送过来的数据
			InputStream inputStream = socket.getInputStream();
			DataInputStream dataInputStream = new DataInputStream(inputStream);

			// 2.读取客户端发送过来的文件类型
			String suffix = dataInputStream.readUTF();
			String name = dataInputStream.readUTF();
			byte[] buffer = new byte[1024];

			System.out.println("已接收到后缀"+suffix);

			// 3.定义一个字节输出管道

			File file = new File( "./"+name + suffix);

			file.createNewFile();

			FileOutputStream fileOutputStream = new FileOutputStream(file);
			int len;
			while ((len=dataInputStream.read(buffer))>0){
				fileOutputStream.write(buffer,0,len);
			}

			dataInputStream.close();
			fileOutputStream.close();


		}catch (Exception e){
			e.printStackTrace();
		}
	}
}

/*------------------------------------------类分界线--------------------------------------------------*/

/**
 * 目标: 实现客户端上传任意类型的文件数据给服务端存储起来
 */
public class Client {
	public static void main(String[] args) {
		try{

			// 1.请求与服务端的socket连接
			Socket socket = new Socket("127.0.0.1", 8888);
			OutputStream outputStream = socket.getOutputStream();


			File file = new File("/Users/zhangliuxiao/Downloads/Sentinel.mp4");
			String filename = file.getName();
			String name = filename.substring(0,filename.lastIndexOf('.'));
			System.out.println(name);
			String extension = filename.substring(filename.lastIndexOf('.'));
			System.out.println(extension);


			// 2.把字节输出流包装成一个数据输出流
			DataOutputStream dataOutputStream = new DataOutputStream(outputStream);

			// 3.先发送上传文件的后缀给服务器
			dataOutputStream.writeUTF(extension);
			dataOutputStream.writeUTF(name);

			// 4.把文件数据发送给服务端进行接收
			FileInputStream fileInputStream = new FileInputStream(file);
			byte[] buffer = new byte[1024];
			int len;
			while ((len=fileInputStream.read(buffer))>0){
				dataOutputStream.write(buffer,0,len);
			}

			dataOutputStream.flush();

			socket.shutdownOutput();

			outputStream.close();
			fileInputStream.close();
			dataOutputStream.close();

		}catch (Exception e){
			e.printStackTrace();
		}
	}
}

2.8 Java BIO 模式下的端口转发思想

请添加图片描述

/**
 * 目标:BIO模式下的端口转发思想-服务端实现
 *
 *  服务端实现的需求:
 *  	1.注册端口
 *  	2.接受客户端的socket连接,交给一个独立的线程来处理
 *  	3.把当前连接的客户端socket存入到一个在线socket集合中来保存
 *  	4.接收客户端的消息,然后推送给当前所有在线的socket接收
 */
public class Server {
	public static List<Socket> allSocketOnline = new ArrayList<>();
	public static void main(String[] args) {
		try {
			ServerSocket serverSocket = new ServerSocket(9999);
			while (true){
				Socket socket = serverSocket.accept();
				// 把登录的客户端中的socket存入到一个在线集合中去
				allSocketOnline.add(socket);
				// 为当前成功登录的socket分配一个独立的线程来与之通信
				ServerReader serverReader = new ServerReader(socket);
				serverReader.start();
			}
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
	}
}

/*------------------------------------------类分界线---------------------------------------------------*/

public class ServerReader extends Thread{

	private Socket socket;

	public ServerReader(Socket socket) {
		this.socket = socket;
	}

	@Override
	public void run() {

		try {
			InputStream inputStream = socket.getInputStream();
			BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
			String msg;
			while ((msg = bufferedReader.readLine()) != null){
				sendMsgToAllClient(msg);
			}
		} catch (IOException e) {
			System.out.println("当前有人下线了");

			throw new RuntimeException(e);
		}
	}

	/**
	 * 把当前客户端发来的消息推送给所有在线的socket
	 * @param msg
	 */

	private void sendMsgToAllClient(String msg) throws IOException {
		for (Socket socket : Server.allSocketOnline) {
			OutputStream outputStream = socket.getOutputStream();
			PrintStream printStream = new PrintStream(outputStream);
			printStream.println(msg);
			printStream.flush();
		}
	}
}