目前常见的服务器模型主要有三种：阻塞服务器，并发服务器以及异步服务器。三种形式各有利弊，下面介绍一下。
第一种阻塞式服务器是最好实现的服务器，也是问题最多的服务器，上一篇文章中的示例代码就是典型的阻塞式服务器。客户端发送到服务器的请求，服务器会进行排队，依次处理请求。前一个请求没有处理完成，服务器不会处理后面的请求。这种服务器很容易进行攻击，只需要向服务器发送一个处理时间很长的请求，就会将其他的请求堵在门外，导致其他请求无法得到处理，所以，这种服务器更多的是作为理论模型，实际应用并不多。
第二种是并发式服务器，这种服务器处理请求时，每接收到一个请求，就启动一个线程处理该请求，这种模式的服务器，好处是不会出现阻塞式服务器请求被拥堵的情况，但是也是存在问题的，服务器启动线程是有一定的开销的，请求数量不多的时候，服务器启动线程没有问题，但是请求过多时，将会导致服务器的资源耗尽。所以，会存在一种方式——建立线程池来处理请求，每当请求到来时，向线程池申请线程进行处理，这样，线程池开放多少线程是固定的，不会导致系统资源耗尽，但是依然会有一些问题，当线程池被占用满时，还是有可能出现请求被阻塞的情况，所以这种方式是一种折中的方式。但是，对于并发请求不是很多的场景来说， 使用这种方式是完全可以的。
第三种方式是异步服务器，使用该种方式，一般要借助于系统的异步IO机制，如select或poll，这种方式，当一个请求到达时，我们可以先将请求注册，当有数据可以读取时，会得到通知，这时候我们处理请求，这样，服务器进程没有必要阻塞处理，也不会存在很大的系统开销，因此，目前对于并发量要求比较高的服务器，一般都是采用这种方式。
阻塞式服务器
这里的示例是服务器将字符串转换为大写并追加_OK，由于TCP传输数据是流模式，没有数据边界，服务器端只有拿到终结符，才认为一个请求发送完成，否则会一直等待读取(除非设置超时)。首先给出服务端的代码：
package com.tzSocket.server;
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;
/**
* create by tz on 2018-08-02
*/
public class ToUpperTCPBlockServer {
//服务器IP
public static final String SERVER_IP = "127.0.0.1";
//服务器端口号
public static final int SERVER_PORT = 10016;
//请求终结字符串
public static final char REQUEST_END_CHAR = '#';
/***
* 启动服务器
* @param serverPort 服务器监听的端口号，
* @param serverIP 服务器ip无需指定，系统自动分配
*/
public void startServer(String serverIP, int serverPort) {
//创建服务器地址对象
InetAddress serverAddr;
try {
serverAddr = InetAddress.getByName(serverIP);
} catch (UnknownHostException e) {
e.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("_ok");
recvStrBuilder.append('#');
String recvStr = recvStrBuilder.toString();
//向客户端写出处理后的字符串
OutputStream out = connection.getOutputStream();
out.write(recvStr.toUpperCase().getBytes());
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
ToUpperTCPBlockServer server = new ToUpperTCPBlockServer();
server.startServer(SERVER_IP,SERVER_PORT);
}
}
下面是客户端代码：
package com.tzSocket.client;
import com.tzSocket.server.ToUpperTCPBlockServer;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
/**
* create by tz on 2018-08-02
*/
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,
"tzTCPSocket" + ToUpperTCPBlockServer.REQUEST_END_CHAR);
System.out.println("收到:" + recvStr);
}
}
返回结果是：
收到:TZTCPSOCKET_OK
并发服务器
并发服务器是基于Executor线程池，与阻塞式服务器相比，具有更好的并发现，多客户端访问更加高效。
并发服务器的服务端示例如下：
package com.tzSocket.server;
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;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
/**
* create by tz on 2018-08-02
*/
public class ToUpperTCPThreadServer {
//服务器IP
public static final String SERVER_IP = "127.0.0.1";
//服务器端口号
public static final int SERVER_PORT = 10005;
//请求终结字符串
public static final char REQUEST_END_CHAR = '#';
/***
* 启动服务器
* @param 服务器监听的端口号，服务器ip无需指定，系统自动分配
*/
public void startServer(String serverIP, int serverPort) {
//创建服务器地址对象
InetAddress serverAddr = null;
try {
serverAddr = InetAddress.getByName(serverIP);
} catch (UnknownHostException e) {
e.printStackTrace();
}
//Java提供了ServerSocket作为服务器
//这里使用了Java的自动关闭的语法，很好用
try(ServerSocket serverSocket = new ServerSocket(SERVER_PORT, 5, serverAddr)) {
Executor executor = Executors.newFixedThreadPool(100);
while (true) {
StringBuilder recvStrBuilder = new StringBuilder();
try {
//有客户端向服务器发起tcp连接时，accept会返回一个Socket
//该Socket的対端就是客户端的Socket
//具体过程可以查看TCP三次握手过程
Socket connection = serverSocket.accept();
//利用线程池，启动线程
executor.execute(new Runnable() {
@Override
public void run() {
//使用局部引用，防止connection被回收
Socket conn = connection;
try{
InputStream in = conn.getInputStream();
//读取客户端的请求字符串，请求字符串以#终结
for (int c = in.read(); c != REQUEST_END_CHAR; c = in.read()) {
recvStrBuilder.append((char)c);
}
recvStrBuilder.append("_isOK");
recvStrBuilder.append('#');
String recvStr = recvStrBuilder.toString();
//向客户端写出处理后的字符串
OutputStream out = conn.getOutputStream();
out.write(recvStr.toUpperCase().getBytes());
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (conn != null) {
conn.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
});
} catch (IOException e) {
e.printStackTrace();
}
}
}catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
ToUpperTCPThreadServer server = new ToUpperTCPThreadServer();
server.startServer(SERVER_IP, SERVER_PORT);
}
}
与阻塞式服务器相比并发服务器差别仅在于当accept返回socket后，启动线程处理，这里使用了Excutor，基于线程池进行处理。另外注意在Runnable的run方法中，使用一个局部对象引用connection，防止被JVM回收。
客户端只需做修改即可：
package com.tzSocket.client;
import com.tzSocket.server.ToUpperTCPBlockServer;
import com.tzSocket.server.ToUpperTCPThreadServer;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
/**
* create by tz on 2018-08-03
*/
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(ToUpperTCPThreadServer.SERVER_IP, ToUpperTCPThreadServer.SERVER_PORT,
"tzTCPSocket" + ToUpperTCPBlockServer.REQUEST_END_CHAR);
System.out.println("收到:" + recvStr);
}
}
测试结果如下：
收到:TZTCPSOCKET_ISOK
异步服务器
最后一种服务器模式，如果开发异步服务器，需要使用Java的NIO才可以，所以，会发现代码中很多使用的类，与之前的不同了，下面是服务端示例代码：
package com.tzSocket.server;
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;
/**
* create by tz on 2018-08-03
*/
public class ToUpperTCPNonBlockServer {
//服务器IP
public static final String SERVER_IP = "127.0.0.1";
//服务器端口号
public static final int SERVER_PORT = 10005;
//请求终结字符串
public static final char REQUEST_END_CHAR = '#';
public void startServer(String serverIP, int serverPort) throws IOException {
//使用NIO需要用到ServerSocketChannel
//其中包含一个ServerSocket对象
ServerSocketChannel serviceChannel = ServerSocketChannel.open();
//创建地址对象
InetSocketAddress localAddr = new InetSocketAddress(serverIP, serverPort);
//服务器绑定地址
serviceChannel.bind(localAddr);
//设置为非阻塞
serviceChannel.configureBlocking(false);
//注册到selector，会调用ServerSocket的accept
//我们用selector监听accept能否返回
//当调用accept可以返回时，会得到通知
//注意，是可以返回，还需要调用accept
Selector selector = Selector.open();
serviceChannel.register(selector, SelectionKey.OP_ACCEPT);
while (true) {
//调用select，阻塞在这里，直到有注册的channel满足条件
selector.select();
//如果走到这里，有符合条件的channel
//可以通过selector.selectedKeys().iterator()拿到符合条件的迭代器
Iterator<SelectionKey> keys = selector.selectedKeys().iterator();
//处理满足条件的keys
while (keys.hasNext()) {
//取出一个key并移除
SelectionKey key = keys.next();
keys.remove();
try{
if (key.isAcceptable()) {
//有accept可以返回
//取得可以操作的channel
ServerSocketChannel server = (ServerSocketChannel) key.channel();
//调用accept完成三次握手，返回与客户端可以通信的channel
SocketChannel channel = server.accept();
//将该channel置非阻塞
channel.configureBlocking(false);
//注册进selector，当可读或可写时将得到通知，select返回
channel.register(selector, SelectionKey.OP_READ);
} else if (key.isReadable()) {
//有channel可读,取出可读的channel
SocketChannel channel = (SocketChannel) key.channel();
//创建读取缓冲区,一次读取1024字节
ByteBuffer buffer = ByteBuffer.allocate(1024);
channel.read(buffer);
//锁住缓冲区，缓冲区使用的大小将固定
buffer.flip();
//附加上buffer，供写出使用
key.attach(buffer);
key.interestOps(SelectionKey.OP_WRITE);
} else if (key.isWritable()) {
//有channel可写,取出可写的channel
SocketChannel channel = (SocketChannel) key.channel();
//取出可读时设置的缓冲区
ByteBuffer buffer = (ByteBuffer) key.attachment();
//将缓冲区指针移动到缓冲区开始位置
buffer.rewind();
//读取为String
String recv = new String(buffer.array());
//清空缓冲区
buffer.clear();
buffer.flip();
//写回数据
byte[] sendBytes = recv.toUpperCase().getBytes();
channel.write(ByteBuffer.wrap(sendBytes));
//变为等待读
key.interestOps(SelectionKey.OP_READ);
}
} catch (IOException e) {
key.cancel();
key.channel().close();
}
}
}
}
public static void main(String[] args) {
ToUpperTCPNonBlockServer server = new ToUpperTCPNonBlockServer();
try {
server.startServer(SERVER_IP, SERVER_PORT);
} catch (IOException e) {
e.printStackTrace();
}
}
}
客户端代码如下：
package com.tzSocket.client;
import com.tzSocket.server.ToUpperTCPNonBlockServer;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
/**
* create by tz on 2018-08-02
*/
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(ToUpperTCPNonBlockServer.SERVER_IP, ToUpperTCPNonBlockServer.SERVER_PORT,
"tzTCPSocket" + ToUpperTCPNonBlockServer.REQUEST_END_CHAR);
System.out.println("收到:" + recvStr);
}
}
结果如下：
收到:TZTCPSOCKET
可以看到，新的服务器使用了ServerSocketChannel以及SocketChannel，而不再是之前ServerSocket以及Socket，异步服务器的好处在于，服务器没有工作可做的时候，会等在select调用上，不会占用系统资源，而当不同的条件满足时，又可以第一时间被唤醒，执行相应的操作，所以无论从资源的利用上，还是从响应的及时性上都优于前两种。另外，如果write和read的时间比较长，处理也可以放到线程中处理，这样就结合了并发服务器的优势。
网友评论