java -socket编程三：几种常用的服务器模型

 上一篇简单介绍了Socket的原理，并通过简单的程序，实现了UDP传输数据，本篇文章则主要说明以下常见的几种服务器模型。目前常见的服务器模型主要有三种：阻塞服务器，并发服务器以及异步服务器。三种形式各有利弊，下面介绍一下。

        阻塞式服务器是最好实现的服务器，也是问题最多的服务器，上一篇文章中的示例代码就是典型的阻塞式服务器。客户端发送到服务器的请求，服务器会进行排队，依次处理请求。前一个请求没有处理完成，服务器不会处理后面的请求。这种服务器很容易进行攻击，只需要向服务器发送一个处理时间很长的请求，就会将其他的请求堵在门外，导致其他请求无法得到处理，所以，这种服务器更多的是作为理论模型，实际应用并不多。

        第二种是并发式服务器，这种服务器处理请求时，每接收到一个请求，就启动一个线程处理该请求，这种模式的服务器，好处是不会出现阻塞式服务器请求被拥堵的情况，但是也是存在问题的，服务器启动线程是有一定的开销的，请求数量不多的时候，服务器启动线程没有问题，但是请求过多时，将会导致服务器的资源耗尽。所以，会存在一种方式——建立线程池来处理请求，每当请求到来时，向线程池申请线程进行处理，这样，线程池开放多少线程是固定的，不会导致系统资源耗尽，但是依然会有一些问题，当线程池被占用满时，还是有可能出现请求被阻塞的情况，所以这种方式是一种折中的方式。但是，对于并发请求不是很多的场景来说， 使用这种方式是完全可以的。

        第三种方式是异步服务器，使用该种方式，一般要借助于系统的异步IO机制，如select或poll，这种方式，当一个请求到达时，我们可以先将请求注册，当有数据可以读取时，会得到通知，这时候我们处理请求，这样，服务器进程没有必要阻塞处理，也不会存在很大的系统开销，因此，目前对于并发量要求比较高的服务器，一般都是采用这种方式。

      本文先给出基于TCP的阻塞式服务器，后面两篇文章再先后给出其他两种服务器的实现示例。示例还是基于前一篇文章的功能，服务器将字符串转换为大写，首先给出客户端的代码，后面的几种服务器模型介绍，也是用这个客户端，只是将一些服务器开放的常量替换即可。

package socket;


import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
public class ToUpperTCPClient {

//客户端使用的TCP Socket
private Socket clientSocket;

public String toUpperRemote(String serverIp, int serverPort, String str) {
StringBuilder recvStrBuilder = new StringBuilder();
try {
//创建连接服务器的Socket
clientSocket = new Socket(serverIp, serverPort);

//写出请求字符串
OutputStream out = clientSocket.getOutputStream();
out.write(str.getBytes());

//读取服务器响应
InputStream in = clientSocket.getInputStream();
for (int c = in.read(); c != '#'; c = in.read()) {
recvStrBuilder.append((char)c);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (clientSocket != null) {
clientSocket.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}

return recvStrBuilder.toString();
}

public static void main(String[] args) {
ToUpperTCPClient client = new ToUpperTCPClient();
String recvStr = client.toUpperRemote(ToUpperTCPBlockServer.SERVER_IP, ToUpperTCPBlockServer.SERVER_PORT, 
"我是客户端的信息" + ToUpperTCPBlockServer.REQUEST_END_CHAR);
System.out.println("收到:" + recvStr);
}
}

在main函数中发送时，需要最后叠加一个服务器请求终结符，上一篇文章有提到过，由于TCP传输数据是流模式，没有数据边界，服务器端只有拿到终结符，才认为一个请求发送完成，否则会一直等待读取(除非设置超时)。下面是服务器的代码

package socket;


import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;


public class ToUpperTCPBlockServer {

//服务器IP
public static final String SERVER_IP = "127.0.0.1";

//服务器端口号
public static final int SERVER_PORT = 10006;

//请求终结字符串
public static final char REQUEST_END_CHAR = '#';

/***
* 启动服务器
* @param 服务器监听的端口号，服务器ip无需指定，系统自动分配
*/
public void startServer(String serverIP, int serverPort) {

//创建服务器地址对象
InetAddress serverAddr;
try {
serverAddr = InetAddress.getByName(serverIP);
} catch (UnknownHostException e1) {
e1.printStackTrace();
return;
}

//Java提供了ServerSocket作为服务器
//这里使用了Java的自动关闭的语法
try (ServerSocket serverSocket = new ServerSocket(SERVER_PORT, 5, serverAddr)) {
while (true) {
StringBuilder recvStrBuilder = new StringBuilder();

//有客户端向服务器发起tcp连接时，accept会返回一个Socket
//该Socket的対端就是客户端的Socket
//具体过程可以查看TCP三次握手过程
try (Socket connection = serverSocket.accept()) {
InputStream in = connection.getInputStream();

//读取客户端的请求字符串，请求字符串以#终结
for (int c = in.read(); c != REQUEST_END_CHAR; c = in.read()) {
recvStrBuilder.append((char)c);
}
recvStrBuilder.append('#');
System.out.println("客户端发来信息"+recvStrBuilder);

String recvStr = recvStrBuilder.toString();

//向客户端写出处理后的字符串
OutputStream out = connection.getOutputStream();
out.write(recvStr.toUpperCase().getBytes());
} catch (IOException e) {
e.printStackTrace();
}
}
} catch (IOException e) {
e.printStackTrace();
}
}

public static void main(String[] args) {
ToUpperTCPBlockServer server = new ToUpperTCPBlockServer();
server.startServer(SERVER_IP, SERVER_PORT);
System.out.println("服务器已经启动"); }
}

请求终结符就是一个#，那就意味着请求中不可以再包含#了，否则会被当做终结符。

        以上就是一个简单的阻塞服务器，如果服务器处理的字符串特别长，就有可能影响其后的请求处理，因为代码正执行到toUpperCase，没有返回，导致无法执行accept，从而无法完成TCP三次握手，也就没有办法建立连接。