BIO与NIO

IO(BIO) 和NIO区别

其本质就是阻塞和非阻塞的区别
1、 阻塞概念
应用程序在获取网路数据的时候，如果网络传输数据很慢，就会一直等待，直到传输完毕为止
2、非阻塞概念
应用程序直接可以获取已经准备好的数据，无需等待
3、IO为同步阻塞形式，NIO为同步非阻塞形式，NIO并没有实现异步，在JDK1.7后升级的NIO库包，
支持异步非阻塞模型NIO2.0(AIO)
4、BIO:同步阻塞式IO,服务器实现模式为一个请求连接一个线程，即：客户端有链接请求是服务器端就
需要启动一个线程进行处理，如果这个链接不做任何事情就会造成不必要的线程开销，当然可以通过
线程池机制进行改善
5、NIO：同步非阻塞式IO，服务器实现模式为一个请求一个线程，即客户端发送的链接请求都会注册到多
路复用器上，多路复用器轮询到连接有I/O请求是才启动一个线程进行处理
		同步时，应用程序直接参与IO读写操作，并且我们的应用程序会直接阻塞到某一个方法上，直到纾
		解准备就绪，或者采用轮询的测试实现检查数据的就绪状态，如果就绪则获取数据
		异步时，则所有的IO读写操作交给操作系统，与我们的应用程序没有直接关系，我们的程序不需要
		关系IO读写，当操作系统完成了IO读写操作时，会给我们应用程序发送通知，我们的应用程序直接
		拿走数据即可

伪异步

由于BIO一个酷虎需要一个线程去处理，因此进行优化，后端使用线程池来处理多个客户端的请求接入，
形成客户端个数M：线程池最大的线程数	N的比例关系，其中M可以远远大于N，通过线程池可以灵
活的调配线程资源，试着线程的最大值，防止由于海量并发接入导致线程耗尽
原理：当有心的客户端接入时，将客户端的Socket封装成一个Task（该Task任务实现了
java的Runnable接口）投递到后端线程池中进行处理，由于线程池可以设置消息队列的大小以
及线程池的最大值，
因此他的资源占用是可控的，无论多少个客户端的并发访问，都不会导致资源的耗尽或者宕机

使用多个线程支持多个请求

服务器实现模式为一个链接，一个线程，当客户端连有链接请求时，服务器端就需要启动一
个线程进行处理，通过线程池进行处理

tcp服务器端…

class TcpServer {
	public static void main(String[] args) throws IOException {
		System.out.println("socket tcp服务器端启动....");
		ServerSocket serverSocket = new ServerSocket(8080);
		// 等待客户端请求
		try {
			while (true) {
				Socket accept = serverSocket.accept();
				new Thread(new Runnable() {
					@Override
					public void run() {
						try {
							InputStream inputStream = accept.getInputStream();
							// 转换成string类型
							byte[] buf = new byte[1024];
							int len = inputStream.read(buf);
							String str = new String(buf, 0, len);
							System.out.println("服务器接受客户端内容:" + str);
						} catch (Exception e) {
						}
					}
				}).start();
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			serverSocket.close();
		}
	}
}

客户端

public class TcpClient {
	public static void main(String[] args) throws UnknownHostException, IOException {
		System.out.println("socket tcp 客户端启动....");
		Socket socket = new Socket("127.0.0.1", 8080);
		OutputStream outputStream = socket.getOutputStream();
		outputStream.write("我是蚂蚁课堂".getBytes());
		socket.close();
	}
}

使用线程池管理线程

//tcp服务器端...
class TcpServer {
	public static void main(String[] args) throws IOException {
		ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
		System.out.println("socket tcp服务器端启动....");
		ServerSocket serverSocket = new ServerSocket(8080);
		// 等待客户端请求
		try {
			while (true) {
				Socket accept = serverSocket.accept();
				//使用线程
				newCachedThreadPool.execute(new Runnable() {
					@Override
					public void run() {
						try {
							InputStream inputStream = accept.getInputStream();
							// 转换成string类型
							byte[] buf = new byte[1024];
							int len = inputStream.read(buf);
							String str = new String(buf, 0, len);
							System.out.println("服务器接受客户端内容:" + str);
						} catch (Exception e) {
						}
					}
				});
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			serverSocket.close();
		}
	}
}

IO模型关系

什么事阻塞和非阻塞

阻塞：应用程序在获取网路数据的时候，如果网络传输很慢，那么程序就一直等待，
直到传输完毕

非阻塞：应用程序直接可以获取已经准备好的数据，无需等待，IO为同步阻塞形式，
NIO为同步非阻塞形式。NIO没有实现异步，在JDK1.7之后，升级了NIO库，
直接异步非阻塞通讯模型NIO2.0(即：AIO)

NIO非阻塞代码

//nio   异步非阻塞
class Client {
	public static void main(String[] args) throws IOException {
		System.out.println("客户端已经启动....");
		// 1.创建通道
		SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 8080));
		// 2.切换异步非阻塞
		sChannel.configureBlocking(false);
		// 3.指定缓冲区大小
		ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
		Scanner scanner=  new Scanner(System.in);
		while (scanner.hasNext()) {
			String str=scanner.next();
			byteBuffer.put((new Date().toString()+"\n"+str).getBytes());
			// 4.切换读取模式
			byteBuffer.flip();
			sChannel.write(byteBuffer);
			byteBuffer.clear();
		}
		sChannel.close();
	}
}

服务端

// nio
class Server {
	public static void main(String[] args) throws IOException {
		System.out.println("服务器端已经启动....");
		// 1.创建通道
		ServerSocketChannel sChannel = ServerSocketChannel.open();
		// 2.切换读取模式
		sChannel.configureBlocking(false);
		// 3.绑定连接
		sChannel.bind(new InetSocketAddress(8080));
		// 4.获取选择器
		Selector selector = Selector.open();
		// 5.将通道注册到选择器 "并且指定监听接受事件"
		sChannel.register(selector, SelectionKey.OP_ACCEPT);
		// 6. 轮训式 获取选择 "已经准备就绪"的事件
		while (selector.select() > 0) {
			// 7.获取当前选择器所有注册的"选择键(已经就绪的监听事件)"
			Iterator<SelectionKey> it = selector.selectedKeys().iterator();
			while (it.hasNext()) {
				// 8.获取准备就绪的事件
				SelectionKey sk = it.next();
				// 9.判断具体是什么事件准备就绪
				if (sk.isAcceptable()) {
					// 10.若"接受就绪",获取客户端连接
					SocketChannel socketChannel = sChannel.accept();
					// 11.设置阻塞模式
					socketChannel.configureBlocking(false);
					// 12.将该通道注册到服务器上
					socketChannel.register(selector, SelectionKey.OP_READ);
				} else if (sk.isReadable()) {
					// 13.获取当前选择器"就绪" 状态的通道
					SocketChannel socketChannel = (SocketChannel) sk.channel();
					// 14.读取数据
					ByteBuffer buf = ByteBuffer.allocate(1024);
					int len = 0;
					while ((len = socketChannel.read(buf)) > 0) {
						buf.flip();
						System.out.println(new String(buf.array(), 0, len));
						buf.clear();
					}
				}
				it.remove();
			}
		}
	}
}

选择 KEY

1、SelectionKey.OP_CONNECT    可读
2、SelectionKey.OP_ACCEPT       可写
3、SelectionKey.OP_READ            可连接
4、SelectionKey.OP_WRITE          可接受连接

如果你对不止一种事件感兴趣，那么可以用“位或”操作符将常量连接起来，如下：
int interestSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE;