既然跟网络内容有关就不得不学习网络IO模型，时代在进步，技术也在进步，采取使用那种网络IO模型就已经确定应用程序规模
阻塞IO（blocking IO）
在linux中，默认情况下所有的socket都是blocking，一个典型的读操作流程大概是这样：
图1 阻塞IO
大部分的IO接口都是阻塞型的。所谓阻塞型接口是指系统调用（一般是IO接口）不返回调用结果并让当前线程一直阻塞，只有当该系统调用获得结果或者超时出错时才返回。
当用户进程调用了recvfrom这个系统调用，kernel就开始了IO的第一个阶段：准备数据。对于network io来说，很多时候数据在一开始还没有到达（比如，还没有收到一个完整的UDP包），这个时候kernel就要等待足够的数据到来。而在用户进程这边，整个进程会被阻塞。当kernel一直等到数据准备好了，它就会将数据从kernel中拷贝到用户内存，然后kernel返回结果，用户进程才解除block的状态，重新运行起来
所以，blocking IO的特点就是在IO执行的两个阶段（等待数据和拷贝数据两个阶段）都被block了。
对于网络编程，在第一阶段系统内核阻塞等侍接收完整数据包，主进程/线程无法执行运算同响应其它请求，非常浪费硬件资源，解决方案是每个socket开个线程/进程独立处理
public final class ServerBio {
private static int DEFAULT_PORT = 12345;
private static ServerSocket server;
private static AtomicInteger ai = new AtomicInteger();
public static void main(String[] args) throws Exception {
try {
server = new ServerSocket(DEFAULT_PORT);
System.out.println("服务器已启动，端口号：" + DEFAULT_PORT);
while (true) {
Socket socket = server.accept();
ai.incrementAndGet();
new Thread(new ServerHandler(socket)).start();
}
} finally {
if (server != null) {
System.out.println("服务器已关闭。");
server.close();
server = null;
}
}
}
public static class ServerHandler implements Runnable {
private Socket socket;
private BufferedReader in = null;
private PrintWriter out = null;
public ServerHandler(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
try {
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
out = new PrintWriter(socket.getOutputStream(), true);
String body;
while (true) {
if ((body = in.readLine()) == null) {
continue;
}
System.out.println("服务器收到消息：" + body);
out.println(ai.get());
}
} catch (Exception e) {
} finally {
if (in != null) {
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (out != null) {
out.close();
}
if (socket != null) {
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
public class ClientBio {
private static int DEFAULT_SERVER_PORT = 12345;
private static String DEFAULT_SERVER_IP = "127.0.0.1";
private static AtomicInteger ai = new AtomicInteger();
private Socket socket = null;
private BufferedReader in = null;
private PrintWriter out = null;
public static void main(String[] args) throws InterruptedException {
while (true) {
send("xxxxxx");
Thread.sleep(1);
}
}
public static void send(String body) {
new ClientBio().send(DEFAULT_SERVER_PORT, body);
}
public void send(int port, String body) {
try {
socket = new Socket(DEFAULT_SERVER_IP, port);
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
out = new PrintWriter(socket.getOutputStream(), true);
out.println(body);
ai.incrementAndGet();
System.out.println("客户端 接收：" + in.readLine());
} catch (Exception e) {
e.printStackTrace();
}
}
}
BIO有个致命的缺点，由于线程/进程资源是有限的，在测试发现当开了500线程左右每接收/创建一个socket时间变得越来越长，也就是说采用BIO模型的瓶颈在500左右（大众机器）
解决方案也简单：线程是有限的，那么就用池程线来重用线程
ServerBioPool.class 只需要添加ExecutorService pool 替换掉Thread即可
private static ExecutorService pool = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors()*10);
public static void main(String[] args) throws Exception {
try {
server = new ServerSocket(DEFAULT_PORT);
System.out.println("服务器已启动，端口号：" + DEFAULT_PORT);
while (true) {
Socket socket = server.accept();
ai.incrementAndGet();
pool.submit(new ServerHandler(socket));
}
} finally {
// 一些必要的清理工作
if (server != null) {
System.out.println("服务器已关闭。");
server.close();
server = null;
}
}
}
上面应用场景比较有限，如果是长连接不释放socket资源的话，每个socket占用一个thread，用thread pool只能优化thread创建和销毁的频率并不能解决thread不足问题，读者可以试下把线程数改成800再测试。
现实与理想差距还是很大的
我们来论证瓶颈是否出现在线程上，屏蔽掉 ServerBioPool.class ClientBio.class 发送接收处理
public static void main(String[] args) throws Exception {
server = new ServerSocket(DEFAULT_PORT);
System.out.println("服务器已启动，端口号：" + DEFAULT_PORT);
while (true) {
Socket socket = server.accept();
ai.incrementAndGet();
System.out.println(ai.get());
}
}
ClientBio.class
public void send(int port, String body) {
try {
socket = new Socket(DEFAULT_SERVER_IP, port);
} catch (Exception e) {
e.printStackTrace();
}
}
结果打印出的数字能突破成千上万
如果client使用bio是无影响的，因为由始至终只有一个socket
小结:使用BIO模型，性能屏颈受线程/进程数上限影响，client可以使用bio