BIO/NIO底层原理分析由来？
两个原因，一BIO/NIO的区别底层原理一直是Java程序员的一个难点、重点，值得学习，也必须要学习；二最近想要入职BAT、TMD进行面试准备，BIO/NIO基本是一个必考问题。
BIO
BIO是什么？
Blocking IO，阻塞IO，同步阻塞IO
同步？
自己去做某件事（Java自己亲自做这件事，并且是指同一个时间点）
阻塞？
类似银行排队去ATM取钱（Java进行IO操作，一直会等到读操作或者写操作完成，当前线程才能去做其他事情）
废话少说上代码
package bio_nio.study;
import java.io .IOException;
import java.io .InputStream;
import java.io .OutputStream;
import java.net.Socket;
/**
* 客户端
*/
public class FirstClient {
public static void main(String[] args) {
try {
Socket socket = new Socket("localhost", 8000);
OutputStream outputStream = socket.getOutputStream();
outputStream.write("hello server, i am client".getBytes());
outputStream.flush();;
InputStream inputStream = socket.getInputStream();
byte[] buffer = new byte[1024];
int length = 0;
// 读取服务端的数据
while ((length = inputStream.read(buffer)) > 0) {
System.out.println(new String(buffer, 0, length));
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
package bio_nio.study;
import java.io .IOException;
import java.io .InputStream;
import java.io .OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
/**
* 服务端
*/
public class FirstServer {
public static void main(String[] args) {
try {
ServerSocket serverSocket = new ServerSocket(8000);
System.out.println("服务器启动成功，监听端口8000");
// 不断监听客户端的请求
while (true) {
Socket socket = serverSocket.accept(); //阻塞
InputStream inputStream = socket.getInputStream();
byte[] buffer = new byte[1024];
int length = 0;
// 读取客户端的数据
while ((length = inputStream.read(buffer)) > 0) {
System.out.println(new String(buffer, 0, length));
}
// 向客户端写数据
OutputStream outputStream = socket.getOutputStream();
outputStream.write("hello java".getBytes());
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
代码分析：
单线程下的通信
- 1.同步：java
- 2.阻塞：
- accept 是阻塞的。
- IO进行操作的时候，要么读操作，要么写操作（前提：单线程环境下而言）。
- BIO中不可能只有一个客户端进行连接，同步阻塞（阻塞主要描述的是IO本身的操作）。
单线程情况如此，那多线程下的BIO呢？
还是先上代码：
package bio_nio.study;
import java.io .IOException;
import java.io .InputStream;
import java.io .OutputStream;
import java.net.Socket;
public class ServerHandler implements Runnable {
//维护一个socket成员变量，记录传来的socket
private Socket socket;
public ServerHandler (Socket socket) {
this.socket = socket;
}
//当前线程要执行的任务
@Override
public void run() {
InputStream inputStream = null;
try {
inputStream = socket.getInputStream();
byte[] buffer = new byte[1024];
int length = 0;
//读取客户端的数据
while ((length = inputStream.read(buffer)) > 0) {
System.out.println(new String(buffer, 0, length));
}
//向客户端写数据
OutputStream outputStream = socket.getOutputStream();
outputStream.write("hello java".getBytes());
} catch (IOException e) {
e.printStackTrace();
}
}
}
package bio_nio.study;
import java.io .IOException;
import java.net.ServerSocket;
import java.net.Socket;
/**
* 多个Socket 多线程
*/
public class SecondServer {
public static void main (String[] args) {
ServerSocket serverSocket = null;
try {
serverSocket = new ServerSocket(8000);
System.out.println("服务器启动成功，监听端口8000");
while (true) {
Socket socket = serverSocket.accept();
// 针对每个连接创建一个线程，去处理IO操作
new Thread(new ServerHandler(socket)).start();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
代码分析：
多线程下的通信
存在的问题：
客户端和服务端交互的本质是数据的交流，不应该在一有Socket连接的时候，就进行new Thread；而应该是在有IO操作的时候再去开启线程。
再介绍一种方法：伪异步IO的方式
BIO中，线程池已经可以解决这种问题。
再上代码：
package bio_nio.study;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* BIO 多个Socket多线程，由线程池执行多个任务
*/
public class ThirdServer {
public static void main (String[] args) {
ServerSocket serverSocket;
ExecutorService executorService = Executors.newFixedThreadPool(60);
try {
serverSocket = new ServerSocket(8000);
System.out.println("服务器启动成功，监听端口8000");
while (true) {
Socket socket = serverSocket.accept();
//使用线程池中的线程去执行每个对应的任务
executorService.execute(new ServerHandler(socket));
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
代码分析：
线程池下的通信
- 线程池，进行IO操作的时候，从线程池中分配一个线程去执行run任务；
- 线程池只提供60个线程，当需求量超过60个线程的时候，则进行等待；
线程池的管理方式带来的问题？
高并发的情况不适用（如果需要600个线程呢？总不能创建600个线程的线程池吧）。
主角出场——NIO
NIO是什么？
New IO，Non-Blocking IO，同步非阻塞
非阻塞？
类似去银行柜台取钱，先去取号，然后在银行大厅等待叫号。（客户端请求连接服务端的时候，服务端将连接请求记录下来，判断是否要进行IO操作）
BIO存在问题？
- a.每一个socket连接服务端都会立刻开启一个线程进行处理。（解决方案：连接，但不立刻开启线程，有IO操作再开启线程）。
- b.每个IO操作完成后，线程就会销毁。（解决方案：不要轻易销毁）
废话少说，上代码
package bio_nio.study;
import java.netInetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
import java.util.Set;
public class NIOServer {
private int port = 8000;
private InetSocketAddress address = null;
// 注册客户端连接信息
private Selector selector;
public NIOServer(int port) {
try {
this.port = port;
address = new InetSocketAddress(this.port);
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
serverSocketChannel.bind(address);
// 服务器通道设置为非阻塞的模式
serverSocketChannel.configureBlocking(false);
selector = Selector.open();
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
System.out.println("服务器启动：" + this.port);
}catch (Exception e) {
e.printStackTrace();
}
}
/**
* Selector开始轮询
*/
public void listen() {
try {
//轮询
while(true) {
//在Selector上连接的数量
int wait = this.selector.select(); //类似accept()是阻塞的
if(wait == 0) continue;
Set<SelectionKey> keys = this.selector.selectedKeys();
Iterator<SelectionKey> iterator = keys.iterator();
while(iterator.hasNext()) {
SelectionKey key = iterator.next();
//针对每一个客户端进行相应的操作
process(key);
iterator.remove();
}
}
}catch (Exception e) {
e.printStackTrace();
}
}
/**
* 处理每一个客户端的请求
*/
public void process(SelectionKey key) throws Exception {
ByteBuffer buffer = ByteBuffer.allocate(1024);
if(key.isAcceptable()) {
ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel();
SocketChannel socketChannel = serverSocketChannel.accept();
socketChannel.configureBlocking(false);
// 客户端一旦连接上来，进行读写操作
// 往这个Selector上注册Key，OP_READ，接下来可以进行读操作
socketChannel.register(selector, SelectionKey.OP_READ);
} else if(key.isReadable()) {
SocketChannel socketChannel = (SocketChannel) key.channel();
int len = socketChannel.read(buffer);
if(len > 0) {
buffer.flip();
String content = new String(buffer.array(), 0, len);
System.out.println(content);
socketChannel.register(selector, SelectionKey.OP_WRITE);
}
buffer.clear();
} else if(key.isWritable()) {
SocketChannel socketChannel = (SocketChannel) key.channel();
socketChannel.write(buffer.wrap("hello nio".getBytes()));
socketChannel.close();
}
}
代码分析：
NIO下的通信
- 在服务端有一个线程，用于记录客户端的连接操作。
- BIO与NIO区别
BIO：ServerSocket、Socket
NIO：ServerSocketChannel服务端 8000、SocketChannel客户端、class Selector {}记录客户端的一个状态 - NIO主要功劳，一Selector机制，二底层使用了Buffer，Buffer构造如图：
Buffer构造
推荐及参考：
可能大家依旧觉得NIO很麻烦，自己使用起来也不是很顺手。首先原理必须要知道，其次Java中的大牛们给我们提供了一个开源框架——netty框架，对NIO的进行了一个很好的封装，感兴趣可以了解下。
参考资料：阿里面试必备之分析IO及NIO的底层原理
