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

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

第一个问题:

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

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

最简单的BIO Server

服务端
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
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);
}
}
}
客户端
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
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);
}
}
}
对应的输出(已按顺序组织)
1
2
3
4
5
6
7
8
9
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):

    netstat -ano|find “9999”

    1
    2
    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
    2
    3
    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.收到服务端消息:你好,请报上名来!

    客户端2

    1
    2
    //客户端2在此处被阻塞
    socket.getInputStream().read(byteBuf);
  1. 实现不了同时服务100个客户端。

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

1
2
3
4
5
//1.当客户端没发消息过来时,此时服务端读取消息时就会阻塞
//2.当读取的数据较多时,线程没有阻塞,但是读取数据的耗时会挺久
clientSocket.getInputStream().read(bytes);
//当给客户端发送的数据较多时,这里线程没有阻塞,但是写数据的耗时会挺久
clientSocket.getOutputStream().write(bytes);
Tips
  1. BIO其实包含两层含义:读取时数据未准备好,当前线程会阻塞;数据的读写是耗时的操作。
  2. server和client之间的通信通过socket的InputStream和OutputStream进行。
  3. server和client之间的通信需要预先定义好通信协议(如示例中就隐含了一个规定,大家每次发送的消息不超过1024个字节,读取时也是读取最多1024个字节,如果违反了这个规定,要吗数据乱了,要吗server或client在读取数据时被阻塞)。
  4. 写数据时要记得flush一下,不然数据只是写到缓存里,并没有发送出去。

引入多线程

服务端
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
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);
}
}
}
}
输出

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

服务端

1
2
3
4
5
6
7
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.向客户端发退出消息

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

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

正常客户端后连接

1
2
3
4
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就是用于注册事件,并检查事件是否已准备好。现在来看下具体代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
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<SocketChannel, Queue> msgQueueMap = new ConcurrentHashMap<SocketChannel, Queue>();

//创建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<SelectionKey> readyKeys = selector.selectedKeys();
Iterator<SelectionKey> 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<String> 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线程池中执行。

源代码

1
2
https://github.com/huangyemin/javatest
https://gitee.com/huangyemin/javatest
零壹视界 wechat
扫描关注我的微信公众号
喜欢就赞赏一下
0%