在接下的文章中，将会分别使用Bio，Nio，Aio，Netty来实现时间查询服务器，比较并分析各种版本的优缺点。
Bio-客户端版本
针对Bio模式下的不同的服务器版本，本节使用统一的客户端版本，客户端的处理逻辑如下：
- 根据hostname和port连接服务器 connect()方法
- 获取socket的输入输出流，通过输出流发送请求，通过输入流读取服务端的响应
- 只要socket没有断开，就一直可以进行请求操作
代码如下：
public class BioClient {
private String hostname;
private int port;
public BioClient(String hostname, int port) {
this.hostname = hostname;
this.port = port;
}
public void start(){
Socket socket = new Socket();
BufferedReader br = null;
BufferedWriter bw = null;
try {
//链接服务端
socket.connect(new InetSocketAddress(hostname, port));
br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
Scanner scanner = new Scanner(System.in);
while(true){
//请求服务端
String message = scanner.nextLine();
bw.write(message);
bw.newLine();
bw.flush();
System.out.println("发送请求：" + message);
String response = br.readLine();
System.out.println("服务端响应：" + response);
}
} catch (IOException e) {
e.printStackTrace();
}finally {
if(br!=null){
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(bw!=null){
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(socket!=null){
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
public static void main(String[] args) {
BioClient bioClient = new BioClient("127.0.0.1", 8080);
bioClient.start();
}
}
对于上述代码，需要注意： 通过socket的输出流发送请求时，需要在消息末尾添加换行符，因为服务端都是根据换行符来区分每一条请求消息的。
Bio-串行接收请求版本
Bio模式下的服务器，在绑定服务端口成功之后，需要调用accept()方法，监听客户端的链接，当客户端经过三次握手成功连接到服务器时，该方法才会返回，accept()方法一次只能接收一个链接（实际上就是去已完成链接队列中取一个socket对象，上一节中已经讲过该知识点，不再累述）。下面我们就看一下在不另外开辟线程执行连接的情景。服务端启动的步骤如下：
- 绑定端口号，bind()，其中默认的backlog（上一节中介绍过）为50
- 调用accep()方法，监听端口，获取链接。该方法调用一次只能返回一个连接，需要不断的执行才能不断的获取链接
- 处理连接，获取链接的请求数据，解析请求，根据请求进行响应
代码如下：
public class BioSimpleServer {
private int port;
public BioSimpleServer(int port) {
this.port = port;
}
public void start(){
try {
ServerSocket serverSocket = new ServerSocket(port);
while(true) {
Socket socket = serverSocket.accept();
BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
String message = br.readLine();
System.out.println("接收到请求：" + message);
String response = null;
if("时间".equals(message)){
response = (new Date()).toString();
}else{
response = "该请求为错误请求";
}
bw.write("服务器时间为：" + response);
bw.newLine();
bw.flush();
System.out.println("服务端回复请求：" + response);
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
BioSimpleServer bioSimpleServer = new BioSimpleServer(8080);
bioSimpleServer.start();
}
}
对于上述代码，对于资源的释放并没有关闭，只是demo而已，注意即可。有几点需要指出：
- 将serverSocket.accept()方法一起后续操作，放在循环中，保证能够不断的接收新的请求
- 注意代码中使用的是readLine()读取数据，意味着客户端发送数据时，最后必须多添加一个换行符。用于区分不同的请求消息。
该中实现存在的问题：
- 如果多个客户端请求，所有的请求都是串行执行的，即第一个请求执行完之后，才能接收并处理后一个请求。因此将接收到的socket扔到一个新的线程去执行，而不阻塞当前的逻辑是非常重要的。
- 该版本，对于每一个连接只能处理一次，因为进入第二次循环的时候，输入输出流的对象就被改变了。这也是必须要开辟一个新线程执行的原因。
综上，对于Bio服务的实现，为了不阻塞接收请求的逻辑，必须开辟一个新的线程执行和处理连接。
Bio-IO线程版本
为了解决请求串行接收执行的问题，我们需要开辟新的线程去执行连接。
首先定义一个执行socket的类，代码如下：
public class BioRunnable implements Runnable {
private Socket socket;
private BufferedReader br;
private BufferedWriter bw;
public BioRunnable(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
try {
br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
while(true){
String line = br.readLine();
System.out.println("获取客户端请求：" + line);
//处理业务逻辑
String response = null;
if("时间".equals(line)){
response = (new Date()).toString();
}else{
response = "不能识别该请求";
}
bw.write(response);
bw.newLine();
bw.flush();
System.out.println("返回客户端结果：" + response);
}
} catch (IOException e) {
e.printStackTrace();
}finally {
if(br!=null){
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(bw!=null){
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(socket!=null){
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
服务端的主流程如下：
public class BioStandardServer {
private int port;
public BioStandardServer(int port) {
this.port = port;
}
public void start(){
try {
ServerSocket serverSocket = new ServerSocket(port);
while(true) {
Socket socket = serverSocket.accept();
new Thread(new BioRunnable(socket)).start();
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
BioStandardServer bioStandardServer = new BioStandardServer(8080);
bioStandardServer.start();
}
}
通过开辟新线程执行处理每一个连接，服务端可以并发的处理每个请求。此外，每一个请求不再是只能发送一次请求，服务端可以处理一个连接的多次请求，只要链接不断开。
该版本存在的问题：针对每一个新的链接，服务端都需要开辟一个新的线程执行，服务端会存在大量线程创建和销毁的过程，当客户端较多时，线程的创建和销毁的开销是不能忽略的。因此我们将会引出下一个Bio的版本，也是我们以往最经常使用的版本-线程池版本
Bio-线程池版本
为了避免线程频繁的销毁和创建，使用线程池来达到线程重用的效果。连接的处理类不变。只修改服务器处理的主逻辑，代码如下：
public class BioThreadPoolServer {
private int port;
private ThreadPoolExecutor executor = new ThreadPoolExecutor(50, 50, 0, TimeUnit.SECONDS,
new LinkedBlockingQueue<Runnable>(1000));
public BioThreadPoolServer(int port) {
this.port = port;
}
public void start(){
try {
ServerSocket serverSocket = new ServerSocket(port);
while(true) {
Socket socket = serverSocket.accept();
executor.execute(new BioRunnable(socket));
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
BioThreadPoolServer bioThreadPoolServer = new BioThreadPoolServer(8080);
bioThreadPoolServer.start();
}
}
通过使用线程池，达到了线程重用的目的
Bio的缺陷
线程池版本在并发量不大的情况下，可以很好的运行，但是当并发量过大时，其性能表现不佳，其主要的问题有如下几方面：
- Bio的服务端对于连接个数有上限限制，默认为1024
- Bio为阻塞模式，当进行读取操作，且读取操作不满足时（例如使用readLine()方法，找不到换行符就不会返回；例如读出数据，但数据接收队列中没有数据，也会阻塞），操作就会则塞，阻塞时不会释放已占有资源，对资源（例如线程资源，线程并没有做事情，却要一直等待）的使用造成浪费。
- Bio的处理模式会受到对方（客户端影响服务端，服务端影响客户端）的影响。例如客服端发送数据缓慢，就会影响到服务端对数据的接收处理，数据读取不完，就会一直占用线程资源，与第2点本质上是一点。客户端和服务端的性能相互影响，耦合性较大。
上面将的集中模式本质上都是Bio的实现，其中都存在Bio存在的问题。下一节，将会讲解Nio是如何解决Bio存在的问题。
欢迎扫描下方二维码，关注公众号，我们可以进行技术交流，共同成长
qrcode_for_gh_5580beb3cba1_430.jpg
