阿里毕玄-测试Java编程能力-我的回答（一）

毕玄老师发表了一篇公众号文章：来测试下你的Java编程能力，本系列文章为其中问题的个人解答。

第一个问题：

基于BIO实现的Server端，当建立了100个连接时，会有多少个线程？如果基于NIO，又会是多少个线程？ 为什么？

说实话，如果面试被问到这个问题，也不敢保证能完全答对。那么就回炉重造一下吧。

最简单的BIO Server

服务端

package com.xetlab.javatest.question1;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.Charset;
public class ServerMain1 {
 private static final Logger logger = LoggerFactory.getLogger(ServerMain1.class);
 public static void main(String[] args) {
 logger.info("0.主线程启动");
 try {
 //服务端初始化，在9999端口监听
 ServerSocket serverSocket = new ServerSocket(9999);
 while (true) {
 //等待客户端连接，如果没有连接就阻塞当前线程
 Socket clientSocket = serverSocket.accept();
 logger.info("1.客户端 {}:{} 已连接", clientSocket.getInetAddress().getHostAddress(), clientSocket.getPort());
 //向客户端发消息
 logger.info("2.向客户端发欢迎消息");
 clientSocket.getOutputStream().write("你好，请报上名来！".getBytes("UTF8"));
 clientSocket.getOutputStream().flush();
 //从客户端读取消息
 StringBuffer msgBuf = new StringBuffer();
 byte[] byteBuf = new byte[1024];
 clientSocket.getInputStream().read(byteBuf);
 msgBuf.append(new String(byteBuf, "UTF8"));
 logger.info("5.收到客户端消息：{}", msgBuf);
 //向客户端发消息
 logger.info("6.向客户端发退出消息");
 clientSocket.getOutputStream().write(String.format("退下，%s！", msgBuf.toString()).getBytes(Charset.forName("UTF8")));
 clientSocket.getOutputStream().flush();
 }
 } catch (IOException e) {
 logger.error("server error", e);
 System.exit(1);
 }
 }
}

客户端

package com.xetlab.javatest.question1;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.net.Socket;
public class ClientMain1 {
 private static final Logger logger = LoggerFactory.getLogger(ClientMain1.class);
 public static void main(String[] args) {
 try {
 Socket socket = new Socket("127.0.0.1", 9999);
 while (true) {
 StringBuffer msgBuf = new StringBuffer();
 byte[] byteBuf = new byte[1024];
 socket.getInputStream().read(byteBuf);
 msgBuf.append(new String(byteBuf, "UTF8"));
 logger.info("3.收到服务端消息：{}", msgBuf);
 logger.info("4.向服务端发送名字消息");
 socket.getOutputStream().write("Mr Nobody.".getBytes("UTF8"));
 socket.getOutputStream().flush();
 msgBuf = new StringBuffer();
 byteBuf = new byte[1024];
 socket.getInputStream().read(byteBuf);
 msgBuf.append(new String(byteBuf, "UTF8"));
 logger.info("7.收到服务端消息：{}", msgBuf);
 if (msgBuf.toString().startsWith("退下")) {
 socket.close();
 logger.info("8.客户端退出");
 break;
 }
 }
 } catch (IOException e) {
 logger.error("client error", e);
 System.exit(1);
 }
 }
}

对应的输出（已按顺序组织）

2019-03-23 23:36:39,480 [INFO] com.xetlab.javatest.question1.ServerMain1 [main] - 0.主线程启动
2019-03-23 23:36:44,883 [INFO] com.xetlab.javatest.question1.ServerMain1 [main] - 1.客户端 127.0.0.1:7473 已连接
2019-03-23 23:36:44,884 [INFO] com.xetlab.javatest.question1.ServerMain1 [main] - 2.向客户端发欢迎消息
2019-03-23 23:36:44,888 [INFO] com.xetlab.javatest.question1.ClientMain1 [main] - 3.收到服务端消息：你好，请报上名来！ 
2019-03-23 23:36:44,891 [INFO] com.xetlab.javatest.question1.ClientMain1 [main] - 4.向服务端发送名字消息
2019-03-23 23:36:44,891 [INFO] com.xetlab.javatest.question1.ServerMain1 [main] - 5.收到客户端消息：Mr Nobody. 
2019-03-23 23:36:44,892 [INFO] com.xetlab.javatest.question1.ServerMain1 [main] - 6.向客户端发退出消息
2019-03-23 23:36:44,892 [INFO] com.xetlab.javatest.question1.ClientMain1 [main] - 7.收到服务端消息：退下，Mr Nobody. 
2019-03-23 23:36:44,892 [INFO] com.xetlab.javatest.question1.ClientMain1 [main] - 8.客户端退出

如果我们按上面的方式实现Server端，答案会是：BIO Server端，一个线程就够了。我们来分析下这种实现方式的优缺点。

优点

1. 简单，适合java socket编程入门。
2. 好像只有简单了。

缺点

1. 一次只能服务一个客户端，别的客户端只能等待，具体表现是：如果同时启动两个慢客户端，那么两个客户端的底层TCP连接是建立好的，先启动的客户端会先得到服务，但后启动的那个客户端会在读取数据时一直被阻塞，如下所示（windows）：
2. netstat -ano|find "9999"

 TCP 127.0.0.1:9999 127.0.0.1:29712 ESTABLISHED 16996
 TCP 127.0.0.1:9999 127.0.0.1:29740 ESTABLISHED 16996

1. 服务端输出

2019-03-24 10:47:48,881 [INFO] com.xetlab.javatest.question1.ServerMain1 [main] - 0.主线程启动
2019-03-24 10:47:52,549 [INFO] com.xetlab.javatest.question1.ServerMain1 [main] - 1.客户端 127.0.0.1:29712 已连接
2019-03-24 10:47:52,550 [INFO] com.xetlab.javatest.question1.ServerMain1 [main] - 2.向客户端发欢迎消息

1. 客户端1收到消息后，休眠

2019-03-24 10:47:52,555 [INFO] com.xetlab.javatest.question1.ClientMain1 [main] - 3.收到服务端消息：你好，请报上名来！

1. 客户端2

//客户端2在此处被阻塞
socket.getInputStream().read(byteBuf);

1. 实现不了同时服务100个客户端。

因此这种方式实现的Server端，只能用于入门示例，不能用于生产环境。另外BIO全称是Blocking IO，即阻塞式IO，这个BIO体现在哪呢？体现在这两处：

//1.当客户端没发消息过来时，此时服务端读取消息时就会阻塞
//2.当读取的数据较多时，线程没有阻塞，但是读取数据的耗时会挺久
clientSocket.getInputStream().read(bytes);
//当给客户端发送的数据较多时，这里线程没有阻塞，但是写数据的耗时会挺久
clientSocket.getOutputStream().write(bytes);

Tips

• BIO其实包含两层含义：读取时数据未准备好，当前线程会阻塞；数据的读写是耗时的操作。
• server和client之间的通信通过socket的InputStream和OutputStream进行。
• server和client之间的通信需要预先定义好通信协议（如示例中就隐含了一个规定，大家每次发送的消息不超过1024个字节，读取时也是读取最多1024个字节，如果违反了这个规定，要吗数据乱了，要吗server或client在读取数据时被阻塞）。
• 写数据时要记得flush一下，不然数据只是写到缓存里，并没有发送出去。

引入多线程

服务端

package com.xetlab.javatest.question1;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.Charset;
public class ServerMain2 {
 private static final Logger logger = LoggerFactory.getLogger(ServerMain2.class);
 public static void main(String[] args) {
 logger.info("0.主线程启动");
 try {
 //服务端初始化，在9999端口监听
 ServerSocket serverSocket = new ServerSocket(9999);
 while (true) {
 //等待客户端连接，如果没有连接就阻塞当前线程
 Socket clientSocket = serverSocket.accept();
 String clientId = String.format("%s:%s", clientSocket.getInetAddress().getHostAddress(), clientSocket.getPort());
 logger.info("1.客户端 {} 已连接", clientId);
 new Thread(new Handler(clientSocket), clientId).start();
 }
 } catch (IOException e) {
 logger.error("server error", e);
 System.exit(1);
 }
 }
 static class Handler implements Runnable {
 private Socket clientSocket;
 public Handler(Socket clientSocket) {
 this.clientSocket = clientSocket;
 }
 public void run() {
 try {
 //向客户端发消息
 logger.info("2.向客户端发欢迎消息");
 clientSocket.getOutputStream().write("你好，请报上名来！".getBytes("UTF8"));
 clientSocket.getOutputStream().flush();
 //从客户端读取消息
 StringBuffer msgBuf = new StringBuffer();
 byte[] byteBuf = new byte[1024];
 clientSocket.getInputStream().read(byteBuf);
 msgBuf.append(new String(byteBuf, "UTF8"));
 logger.info("5.收到客户端消息：{}", msgBuf);
 //向客户端发消息
 logger.info("6.向客户端发退出消息");
 clientSocket.getOutputStream().write(String.format("退下，%s！", msgBuf.toString()).getBytes(Charset.forName("UTF8")));
 clientSocket.getOutputStream().flush();
 } catch (IOException e) {
 logger.error("io error", e);
 }
 }
 }
}
 

输出

客户端保持不变，只是把其中一个在回复名字前故意休眠很久，另一个保持正常。此时各端的输出如下：

服务端

2019-03-24 12:50:56,514 [INFO] com.xetlab.javatest.question1.ServerMain2 [main] - 0.主线程启动
2019-03-24 12:51:02,613 [INFO] com.xetlab.javatest.question1.ServerMain2 [main] - 1.客户端 127.0.0.1:44334 已连接
2019-03-24 12:51:02,613 [INFO] com.xetlab.javatest.question1.ServerMain2 [127.0.0.1:44334] - 2.向客户端发欢迎消息
2019-03-24 12:51:08,331 [INFO] com.xetlab.javatest.question1.ServerMain2 [main] - 1.客户端 127.0.0.1:44347 已连接
2019-03-24 12:51:08,331 [INFO] com.xetlab.javatest.question1.ServerMain2 [127.0.0.1:44347] - 2.向客户端发欢迎消息
2019-03-24 12:51:08,339 [INFO] com.xetlab.javatest.question1.ServerMain2 [127.0.0.1:44347] - 5.收到客户端消息：Mr Nobody. 
2019-03-24 12:51:08,339 [INFO] com.xetlab.javatest.question1.ServerMain2 [127.0.0.1:44347] - 6.向客户端发退出消息

慢客户端先连接，收到消息后，休眠

2019-03-24 12:51:02,619 [INFO] com.xetlab.javatest.question1.ClientMain1 [main] - 3.收到服务端消息：你好，请报上名来！ 

正常客户端后连接

2019-03-24 12:51:08,336 [INFO] com.xetlab.javatest.question1.ClientMain2 [main] - 3.收到服务端消息：你好，请报上名来！ 
2019-03-24 12:51:08,338 [INFO] com.xetlab.javatest.question1.ClientMain2 [main] - 4.向服务端发送名字消息
2019-03-24 12:51:08,339 [INFO] com.xetlab.javatest.question1.ClientMain2 [main] - 7.收到服务端消息：退下，Mr Nobody. 
2019-03-24 12:51:08,340 [INFO] com.xetlab.javatest.question1.ClientMain2 [main] - 8.客户端退出

可以看到，引入多线程后，每个线程服务一个客户端，可以同时服务100个连接了，如果这样实现Server端，IO还是BIO，线程数需要101个，一个线程用于接受客户端连接，100个线程用于服务客户端。同样来分析下优缺点。

优点

1. 简单，和最简单版本相比，只是把和客户端IO相关的处理放到了线程里处理。
2. 可以同时服务N个连接。

缺点

1. 每个线程都要占用内存，当客户端保持长连接，数量越来越多达到一定值时，就会出现错误：OutOfMemoryError：unable to create new native thread。
2. 一个客户端分配一个线程，太浪费资源了，因为BIO的缘故，线程大部分时间都处于阻塞或等待读写状态。
3. 即使机器性能高，内存大，当线程很多时，线程上下文切换也会带来很大的开销。

Tips

编写多线程任务时，可以把执行任务的逻辑使用Runnable接口来实现，这样任务可以直接放到Thread线程对象里执行，也可以提交到线程池中去执行。

NIO上场

有没有可能同时具备方式一和二的优点呢，具体来说就是，一个线程同时服务N个客户端？Yes，NIO就可以！那什么是NIO？NIO即New IO，更多时候我们是看成Non blocking IO，就是非阻塞IO。

具体NIO如何实现一个线程服务N个客户端，在深入代码细节前，我们先理一理。

回顾上面的BIO实现，我们知道有这几个点会阻塞或者响应慢：

1. serverSocket.accept()，这里是服务端等待客户端连接。
2. clientSocket.getInputStream().read()，这里是等待客户端传送数据过来。
3. clientSocket.getOutputStream().write()，这里是往客户端写数据。

由于会阻塞或者响应慢BIO用了不同的线程去分别处理，如果可以只由一个线程去负责检查是否有客户端连接，客户端的数据是否可读，是否可以往客户端写数据，当有对应的事件已经准备好时，再由于当前线程去处理相应的任务，那就完美了。

NIO里有个对象是Selector，这个Selector就是用于注册事件，并检查事件是否已准备好。现在来看下具体代码。

package com.xetlab.javatest.question1;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Map;
import java.util.Queue;
import java.util.Set;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ConcurrentHashMap;
public class ServerMain3 {
 private static final Logger logger = LoggerFactory.getLogger(ServerMain3.class);
 public static void main(String[] args) {
 logger.info("0.主线程启动");
 try {
 Map msgQueueMap = new ConcurrentHashMap();
 //创建channel管理器，用于注册channel的事件
 Selector selector = Selector.open();
 //服务端初始化，在9999端口监听，保留BIO初始化方式用于参照
 //ServerSocket serverSocket = new ServerSocket(9999);
 ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
 //设置非阻塞
 serverSocketChannel.configureBlocking(false);
 serverSocketChannel.socket().bind(new InetSocketAddress(9999));
 //注册可accept事件
 serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
 while (true) {
 //NIO仅有的一个阻塞方法，当有注册的事件产生时，才会返回
 selector.select();
 //产生事件的事件源列表
 Set readyKeys = selector.selectedKeys();
 Iterator keyItr = readyKeys.iterator();
 while (keyItr.hasNext()) {
 SelectionKey readyKey = keyItr.next();
 keyItr.remove();
 if (readyKey.isAcceptable()) {
 ServerSocketChannel serverChannel = (ServerSocketChannel) readyKey.channel();
 //接受客户端
 SocketChannel clientChannel = serverChannel.accept();
 String clientId = String.format("%s:%s", clientChannel.socket().getInetAddress().getHostAddress(), clientChannel.socket().getPort());
 logger.info("1.客户端 {} 已连接", clientId);
 msgQueueMap.put(clientChannel, new ArrayBlockingQueue(100));
 logger.info("2.向客户端发欢迎消息");
 //NIO发消息先放到消息队列里，等可写时再发
 msgQueueMap.get(clientChannel).add("你好，请报上名来！");
 
 //设置非阻塞
 clientChannel.configureBlocking(false);
 //注册可读和可写事件
 clientChannel.register(selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE);
 } else if (readyKey.isReadable()) {
 SocketChannel clientChannel = (SocketChannel) readyKey.channel();
 ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
 int bytesRead = clientChannel.read(byteBuffer);
 if (bytesRead <= 0) {
 continue;
 }
 byteBuffer.flip();
 byte[] msgByte = new byte[bytesRead];
 byteBuffer.get(msgByte);
 final String clientName = new String(msgByte, "UTF8");
 logger.info("5.收到客户端消息：{}", clientName);
 msgQueueMap.get(clientChannel).add(String.format("退下！%s", clientName));
 } else if (readyKey.isWritable()) {
 SocketChannel clientChannel = (SocketChannel) readyKey.channel();
 Queue msgQueue = msgQueueMap.get(clientChannel);
 String msg = msgQueue.poll();
 if (msg != null) {
 ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
 byteBuffer.put(msg.getBytes("UTF8"));
 byteBuffer.flip();
 clientChannel.write(byteBuffer);
 logger.info("6.向客户端发退出消息");
 }
 }
 }
 }
 } catch (IOException e) {
 logger.error("server error", e);
 System.exit(1);
 }
 }
}

上面我们用NIO实现了和原来BIO一模一样的逻辑，NIO确实是只用一个线程高效的解决了问题，但是代码看起来复杂多了。不过我们用伪代码总结一下，会简单一点：

1. 准备好Selector（源代码注释中叫channel多路复用器）。
2. 准备好ServerSocketChannel（对应BIO里的ServerSocket）。
3. ServerSocketChannel向Selector注册accept事件（即客户端连接就绪事件）
4. 循环

• 检查Selector是否有新的就绪事件，如果没有就阻塞等待，如果有就返回产生的就绪事件列表。
• 如果是accept事件（客户端连接就绪事件），就接受客户端连接得到SocketChannel（对应BIO中的Socket），SocketChannel向Selector注册读写就绪事件。
• 如果是读就绪事件，那么读取对应SocketChannel的数据，并进行相应的处理。
• 如果是写就绪事件，那么就把数据写到对应的SocketChannel。

Tips

NIO中，由于是单线程，不能在连接就绪，读写就绪之后的事件处理逻辑执行耗时操作，那样将会让服务性能急剧下降，正确方法应该是把耗时的逻辑放在独立的线程中去执行，或放到专门的worker线程池中执行。

源代码

https://github.com/huangyemin/javatest
https://gitee.com/huangyemin/javatest

關鍵字: Logger Java UTF8