通过实例理解Java网络IO模型
网络IO模型及分类
网络IO模型是一个经常被提到的问题，不同的书或者博客说法可能都不一样，所以没必要死抠字眼，关键在于理解。
Socket连接
不管是什么模型，所使用的socket连接都是一样的。
以下是一个典型的应用服务器上的连接情况。客户的各种设备通过Http协议与Tomcat进程交互，Tomcat需要访问Redis服务器，它与Redis服务器也建了好几个连接。虽然客户端与Tomcat建的是短连接，很快就会断开，Tomcat与Redis是长连接，但是它们本质上都是一样的。
建立一个Socket后，就是"本地IP+port与远端IP+port"的一个配对，这个Socket由应用进程调用操作系统的系统调用创建，在内核空间会有一个与之对应的结构体，而应用程序拿到的是一个文件描述符(File Describer)，就跟打开一个普通的文件一样，可以读写。不同的进程有自己的文件描述符空间，比如进程1中有个socket的fd为100，进程2中也有一个socket的fd为100，它们对应的socket是不一样的（当然也有可能一样，因为socket也可以共享)。
Socket是全双工的，可以同时读和写。
对于不同的应用场景，选用的网络IO模型以及其它方面的选项都不一样。
例如针对客户端的http 请求，我们一般使用短连接，因为客户太多，同时使用App的客户可能很多，但是同一时刻发送请求的客户端远少于正在使用的客户数，如果都建立长连接，内存肯定不够用，所以会用短连接，当然会有http的keep-alive策略，让一次tcp连接多交互几次http数据，这样能减少建链。而对于系统内部的应用，例如Tomcat访问Redis，访问的机器数有限，如果每次都用短连接，会有太多的损耗用在建链上，所以用长连接，可以大大提高效率。
以上说的是长连接和短连接，一般在讨论IO模型时不考虑这个，而是考虑的同步异步，阻塞非阻塞等。而要确定哪种IO模型，也得看场景，对于CPU密集型的应用，例如一次请求需要两个核不停的100％跑1分钟，然后返回结果，这种应用使用哪种IO模型都差不多，因为瓶颈在CPU。所以一般是IO密集型的的应用才考虑如何调整IO模型以获取最大的效率，最典型的就是Web应用，还有像Redis这种应用。
同步异步、阻塞非阻塞的概念
同步与异步：描述的是用户线程与内核的交互方式，同步指用户线程发起IO请求后需要等待或者轮询内核IO操作完成后才能继续执行；而异步是指用户线程发起IO请求后仍然继续执行，当内核IO操作完成后会通知用户线程，或者调用用户线程注册的回调函数。
阻塞与非阻塞：描述是用户线程调用内核IO操作的方式，阻塞是指IO操作需要彻底完成后才返回到用户空间；而非阻塞是指IO操作被调用后立即返回给用户一个状态值，无需等到IO操作彻底完成。
以read函数调用来说明不同的IO模式。从对端读取数据分为两个阶段
(1)数据从设备到内核空间(图中等待数据到达)
(2)数据从内核空间到用户空间(图中数据拷贝)
以下阻塞IO，非阻塞IO，IO多路复用，都是同步IO，最后是异步IO。这个地方可能不好理解， 总之同步IO必须是线程调用了读写函数后，一直阻塞等，或者轮询查结果，而异步IO，调完读写函数后立刻返回，操作完成后操作系统主动告诉线程。
阻塞IO
阻塞IO是指调用了read后，必须等待数据到达，并且复制到了用户空间，才能返回，否则整个线程一直在等待。
所以阻塞IO的问题就是，线程在读写IO的时候不能干其它的事情。
非阻塞IO
非阻塞IO在调用read后，可以立刻返回，然后问操作系统，数据有没有在内核空间准备好，如果准备好了，就可以read出来了。因为不知道什么时候准备好，要保证实时性，就得不断的轮询。
IO多路复用(非阻塞IO)
在使用非阻塞IO的时候，如果每个线程访问网络后都不停的轮询，那么这个线程就被占用了，那跟阻塞IO也没什么区别了。每个线程都轮询自己的socket，这些线程也不能干其它的事情。
如果能有一个专门的线程去轮询所有的socket，如果数据准备好，就找一个线程处理，这就是IO多路复用。当然轮询的线程也可以不用找其他线程处理，自己处理就行，例如redis就是这样的。
IO多路复用，能够让一个或几个线程去管理很多个(可以成千上万)socket连接，这样连接数就不再受限于系统能启动的线程数。
我们把select轮询抽出来放在一个线程里, 用户线程向其注册相关socket或IO请求，等到数据到达时通知用户线程，则可以提高用户线程的CPU利用率.这样, 便实现了异步方式。
这其中用了Reactor设计模式。
异步IO
真正的异步IO需要操作系统更强的支持。 IO多路复用模型中，数据到达内核后通知用户线程，用户线程负责从内核空间拷贝数据; 而在异步IO模型中，当用户线程收到通知时，数据已经被操作系统从内核拷贝到用户指定的缓冲区内，用户线程直接使用即可。
异步IO用了Proactor设计模式。
常见的Web系统里很少使用异步IO，本文不做过多的探讨。
接下来通过一个简单的java版redis说明各种IO模型。
实战
接下来我会编写一个简单的java版的Redis，它只有get和set功能，并且只支持字符串，只是为了演示各种IO模型，其中一些异常处理之类的做的不到位。
1.阻塞IO+单线程+短连接
这种做法只用于写HelloWorld程序，在这里主要为了调试以及把一些公共的类提出来。
首先写一个Redis接口
package org.ifool.niodemo.redis;
public interface RedisClient {
public String get(String key);
public void set(String key,String value);
public void close();
}
另外，有个工具类，用于拿到请求数据后，处理请求，并返回结果，还有一些byte转String，String转byte，在byte前面添加长度等一些函数，供后续使用。
输入是get|key或者set|key|value，输出为0|value或者1|null或者2|bad command。
package org.ifool.niodemo.redis;
import java.util.Map;
public class Util {
//把一个String前边加上一个byte，表示长度
public static byte[] addLength(String str) {
byte len = (byte)str.length();
byte[] ret = new byte[len+1];
ret[0] = len;
for(int i = 0; i < len; i++) {
ret[i+1] = (byte)str.charAt(i);
}
return ret;
}
//根据input返回一个output，操作缓存, prefixLength为true，则在前面加长度
//input:
//->get|key
//->set|key|value
//output:
//->errorcode|response
// ->0|response set成功或者get有值
// ->1|response get的为null
// ->2|bad command
public static byte[] proce***equest(Map<String,String> cache, byte[] request, int length, boolean prefixLength) {
if(request == null) {
return prefixLength ? addLength("2|bad command") : "2|bad command".getBytes();
}
String req = new String(request,0,length);
Util.log_debug("command:"+req);
String[] params = req.split("//|");
if( params.length < 2 || params.length > 3 || !(params[0].equals("get") || params[0].equals("set"))) {
return prefixLength ? addLength("2|bad command") : "2|bad command".getBytes();
}
if(params[0].equals("get")) {
String value = cache.get(params[1]);
if(value == null) {
return prefixLength ? addLength("1|null") : "1|null".getBytes();
} else {
return prefixLength ? addLength("0|"+value) : ("0|"+value).getBytes();
}
}
if(params[0].equals("set") && params.length >= 3) {
cache.put(params[1],params[2]);
return prefixLength ? addLength("0|success"): ("0|success").getBytes();
} else {
return prefixLength ? addLength("2|bad command") : "2|bad command".getBytes();
}
}
public static int LOG_LEVEL = 0; //0 info 1 debug
public static void log_debug(String str) {
if(LOG_LEVEL >= 1) {
System.out.println(str);
}
}
public static void log_info(String str) {
if(LOG_LEVEL >= 0) {
System.out.println(str);
}
}
}
服务端代码如下，在创建服务端ServerSocket的时候，传入端口8888， backlog的作用是客户端建立连接时服务端没法立即处理，能够等待的队列长度。服务端代码
package org.ifool.niodemo.redis.redis1;
import org.ifool.niodemo.redis.Util;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
public class RedisServer1 {
//全局缓存
public static Map<String,String> cache = new ConcurrentHashMap<String,String>();
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(8888,10);
byte[] buffer = new byte[512];
while(true) {
//接受客户端连接请求
Socket clientSocket = null;
clientSocket = serverSocket.accept();
System.out.println("client address:" + clientSocket.getRemoteSocketAddress().toString());
//读取数据并且操作缓存,然后写回数据
try {
//读数据
InputStream in = clientSocket.getInputStream();
int bytesRead = in.read(buffer,0,512);
int totalBytesRead = 0;
while(bytesRead != -1) {
totalBytesRead += bytesRead;
bytesRead = in.read(buffer,totalBytesRead,512-totalBytesRead);
}
//操作缓存
byte[] response = Util.proce***equest(cache,buffer,totalBytesRead,false);
Util.log_debug("response:"+new String(response));
//写回数据
OutputStream os = clientSocket.getOutputStream();
os.write(response);
os.flush();
clientSocket.shutdownOutput();
} catch (IOException e) {
System.out.println("read or write data exception");
} finally {
try {
clientSocket.close();
} catch (IOException ex) {
ex.printStackTrace();
}
}
}
}
}
客户端代码如下：
package org.ifool.niodemo.redis.redis1;
import org.ifool.niodemo.redis.RedisClient;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
public class RedisClient1 implements RedisClient {
public static void main(String[] args) {
RedisClient redis = new RedisClient1("127.0.0.1",8888);
redis.set("123","456");
String value = redis.get("123");
System.out.print(value);
}
private String ip;
private int port;
public RedisClient1(String ip, int port) {
this.ip = ip;
this.port = port;
}
public String get(String key) {
Socket socket = null;
try {
socket = new Socket(ip, port);
} catch(IOException e) {
throw new RuntimeException("connect to " + ip + ":" + port + " failed");
}
try {
//写数据
OutputStream os = socket.getOutputStream();
os.write(("get|"+key).getBytes());
socket.shutdownOutput(); //不shutdown的话对端会等待read
//读数据
InputStream in = socket.getInputStream();
byte[] buffer = new byte[512];
int offset = 0;
int bytesRead = in.read(buffer);
while(bytesRead != -1) {
offset += bytesRead;
bytesRead = in.read(buffer, offset, 512-offset);
}
String[] response = (new String(buffer,0,offset)).split("//|");
if(response[0].equals("2")) {
throw new RuntimeException("bad command");
} else if(response[0].equals("1")) {
return null;
} else {
return response[1];
}
} catch(IOException e) {
throw new RuntimeException("network error");
} finally {
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public void set(String key, String value) {
Socket socket = null;
try {
socket = new Socket(ip, port);
} catch(IOException e) {
throw new RuntimeException("connect to " + ip + ":" + port + " failed");
}
try {
OutputStream os = socket.getOutputStream();
os.write(("set|"+key+"|"+value).getBytes());
os.flush();
socket.shutdownOutput();
InputStream in = socket.getInputStream();
byte[] buffer = new byte[512];
int offset = 0;
int bytesRead = in.read(buffer);
while(bytesRead != -1) {
offset += bytesRead;
bytesRead = in.read(buffer, offset, 512-offset);
}
String bufString = new String(buffer,0,offset);
String[] response = bufString.split("//|");
if(response[0].equals("2")) {
throw new RuntimeException("bad command");
}
} catch(IOException e) {
throw new RuntimeException("network error");
} finally {
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public void close() {
}
}
##2.阻塞IO+多线程+短连接
一般应用服务器用的都是这种模型，主线程一直阻塞accept，来了一个连接就交给一个线程，继续等待连接，然后这个处理线程读写完后负责关闭连接。
服务端代码
package org.ifool.niodemo.redis.redis2;
import org.ifool.niodemo.redis.Util;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Map;
import java.util.concurrent.*;
public class RedisServer2 {
//全局缓存
public static Map<String,String> cache = new ConcurrentHashMap<String,String>();
public static void main(String[] args) throws IOException {
//用于处理请求的线程池
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(200, 1000, 30, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(1000));
ServerSocket serverSocket = new ServerSocket(8888,1000);
while(true) {
//接受客户端连接请求
Socket clientSocket = serverSocket.accept();
Util.log_debug(clientSocket.getRemoteSocketAddress().toString());
//让线程池处理这个请求
threadPool.execute(new RequestHandler(clientSocket));
}
}
}
class RequestHandler implements Runnable{
private Socket clientSocket;
public RequestHandler(Socket socket) {
clientSocket = socket;
}
public void run() {
byte[] buffer = new byte[512];
//读取数据并且操作缓存,然后写回数据
try {
//读数据
InputStream in = clientSocket.getInputStream();
int bytesRead = in.read(buffer,0,512);
int totalBytesRead = 0;
while(bytesRead != -1) {
totalBytesRead += bytesRead;
bytesRead = in.read(buffer,totalBytesRead,512-totalBytesRead);
}
//操作缓存
byte[] response = Util.proce***equest(RedisServer2.cache,buffer,totalBytesRead,false);
Util.log_debug("response:"+new String(response));
//写回数据
OutputStream os = clientSocket.getOutputStream();
os.write(response);
os.flush();
clientSocket.shutdownOutput();
} catch (IOException e) {
System.out.println("read or write data exception");
} finally {
try {
clientSocket.close();
} catch (IOException ex) {
ex.printStackTrace();
}
}
}
}
客户端代码，代码跟前边的没啥变化，只是这次我加了一个多线程的读写，10个线程每个线程读写10000次。
public static void main(String[] args) {
final RedisClient redis = new RedisClient1("127.0.0.1",8888);
redis.set("123","456");
String value = redis.get("123");
System.out.print(value);
redis.close();
System.out.println(new Timestamp(System.currentTimeMillis()));
testMultiThread();
System.out.println(new Timestamp(System.currentTimeMillis()));
}
public static void testMultiThread() {
Thread[] threads = new Thread[10];
for(int i = 0; i < 10; i++) {
threads[i] = new Thread(new Runnable() {
public void run() {
RedisClient redis = new RedisClient2("127.0.0.1",8888);
for(int j=0; j < 300; j++) {
Random rand = new Random();
String key = String.valueOf(rand.nextInt(1000));
String value = String.valueOf(rand.nextInt(1000));
redis.set(key,value);
String value1 = redis.get(key);
}
}
});
threads[i].start();
}
for(int i = 0; i < 10; i++) {
try {
threads[i].join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
用这种方式，在10个并发不停读写的情况下，写10000次，出现了一些没法连接的异常，如下：
java.net.NoRouteToHostException: Can't assign requested address
查了下跟系统参数配置，mac上不知道怎么调就没调，改成读写300次的时候没报错，大约用1s钟。
##3.阻塞IO+多线程+长连接
用短连接的时候，我们可以用inputstream.read() == -1来判断读取结束，但是用长连接时，数据是源源不断的，有可能有粘包或者半包问题，我们需要能从流中找到一次请求的开始和结束。有多种方式，例如使用固定长度、固定分隔符、在前面加长度等方法。此处使用前边加长度的方法，在前面放一个byte，表示一次请求的长度，byte最大是127，所以请求长度不应大于127个字节。
由于我们客户端访问的方式是写完请求后，等待服务端返回数据，等待期间该socket不会被其它人写，所以不存在粘包的问题，只存在半包的问题。有些请求方式可能是写完后在未等待服务端返回就允许其它线程写，那样就可能有半包。
一般客户端用长连接的时候，都是建一个连接池，用的时候上锁获取连接，我们在这个地方直接让一个线程持有一个连接一个读写，这样减少了线程切换与上锁的开销，能实现更大的吞吐量。
客户端代码这次发生了较大变化。
package org.ifool.niodemo.redis.redis3;
import org.ifool.niodemo.redis.RedisClient;
import org.ifool.niodemo.redis.Util;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.sql.Timestamp;
import java.util.Random;
public class RedisClient3 implements RedisClient {
public static void main(String[] args) {
RedisClient redis = new RedisClient3("127.0.0.1",8888);
redis.set("123","456");
String value = redis.get("123");
System.out.print(value);
redis.close();
System.out.println(new Timestamp(System.currentTimeMillis()));
testMultiThread();
System.out.println(new Timestamp(System.currentTimeMillis()));
}
public static void testMultiThread() {
Thread[] threads = new Thread[10];
for(int i = 0; i < 10; i++) {
threads[i] = new Thread(new Runnable() {
public void run() {
RedisClient redis = new RedisClient3("127.0.0.1",8888);
for(int j=0; j < 50; j++) {
Random rand = new Random();
String key = String.valueOf(rand.nextInt(1000));
String value = String.valueOf(rand.nextInt(1000));
redis.set(key,value);
String value1 = redis.get(key);
}
}
});
threads[i].start();
}
for(int i = 0; i < 10; i++) {
try {
threads[i].join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
private String ip;
private int port;
private Socket socket;
public RedisClient3(String ip, int port) {
this.ip = ip;
this.port = port;
try {
socket = new Socket(ip, port);
} catch(IOException e) {
throw new RuntimeException("connect to " + ip + ":" + port + " failed");
}
}
public String get(String key) {
try {
//写数据,前边用一个byte存储长度
OutputStream os = socket.getOutputStream();
String cmd = "get|"+key;
byte length = (byte)cmd.length();
byte[] data = new byte[cmd.length()+1];
data[0] = length;
for(int i = 0; i < cmd.length(); i++) {
data[i+1] = (byte)cmd.charAt(i);
}
os.write(data);
os.flush();
//读数据，第一个字节是长度
InputStream in = socket.getInputStream();
int len = in.read();
if(len == -1) {
throw new RuntimeException("network error");
}
byte[] buffer = new byte[len];
int offset = 0;
int bytesRead = in.read(buffer,0,len);
while(offset < len) {
offset += bytesRead;
bytesRead = in.read(buffer, offset, len-offset);
}
String[] response = (new String(buffer,0,offset)).split("//|");
if(response[0].equals("2")) {
throw new RuntimeException("bad command");
} else if(response[0].equals("1")) {
return null;
} else {
return response[1];
}
} catch(IOException e) {
throw new RuntimeException("network error");
} finally {
}
}
public void set(String key, String value) {
try {
//写数据,前边用一个byte存储长度
OutputStream os = socket.getOutputStream();
String cmd = "set|"+key + "|" + value;
byte length = (byte)cmd.length();
byte[] data = new byte[cmd.length()+1];
data[0] = length;
for(int i = 0; i < cmd.length(); i++) {
data[i+1] = (byte)cmd.charAt(i);
}
os.write(data);
os.flush();
InputStream in = socket.getInputStream();
int len = in.read();
if(len == -1) {
throw new RuntimeException("network error");
}
byte[] buffer = new byte[len];
int offset = 0;
int bytesRead = in.read(buffer,0,len);
while(offset < len) {
offset += bytesRead;
bytesRead = in.read(buffer, offset, len-offset);
}
String bufString = new String(buffer,0,offset);
Util.log_debug(bufString);
String[] response = bufString.split("//|");
if(response[0].equals("2")) {
throw new RuntimeException("bad command");
}
} catch(IOException e) {
throw new RuntimeException("network error");
} finally {
}
}
public void close() {
try {
socket.close();
} catch(IOException ex) {
ex.printStackTrace();
}
}
}
服务端建立一个连接，就由一个线程一直处理这个连接，有数据就处理，没数据就不处理。这样的话，每个连接一个线程，如果连接数较大，就会有问题。
package org.ifool.niodemo.redis.redis3;
import org.ifool.niodemo.redis.Util;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Map;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class RedisServer3 {
//全局缓存
public static Map<String,String> cache = new ConcurrentHashMap<String,String>();
public static void main(String[] args) throws IOException {
//用于处理请求的线程池
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(20, 1000, 30, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(5));
ServerSocket serverSocket = new ServerSocket(8888, 10);
byte[] buffer = new byte[512];
while (true) {
//接受客户端连接请求
Socket clientSocket = null;
try {
clientSocket = serverSocket.accept();
Util.log_debug(clientSocket.getRemoteSocketAddress().toString());
} catch (IOException e) {
e.printStackTrace();
}
//让线程池处理这个请求
threadPool.execute(new RequestHandler(clientSocket));
}
}
}
class RequestHandler implements Runnable{
private Socket clientSocket;
public RequestHandler(Socket socket) {
clientSocket = socket;
}
public void run() {
byte[] buffer = new byte[512];
//读取数据并且操作缓存,然后写回数据
try {
while(true) {
//读数据
InputStream in = clientSocket.getInputStream();
int len = in.read(); //读取长度
if(len == -1) {
throw new IOException("socket closed by client");
}
int bytesRead = in.read(buffer, 0, len);
int totalBytesRead = 0;
while (totalBytesRead < len) {
totalBytesRead += bytesRead;
bytesRead = in.read(buffer, totalBytesRead, len - totalBytesRead);
}
//操作缓存
byte[] response = Util.proce***equest(RedisServer3.cache,buffer, totalBytesRead,true);
Util.log_debug("response:" + new String(response));
//写回数据
OutputStream os = clientSocket.getOutputStream();
os.write(response);
os.flush();
}
} catch (IOException e) {
System.out.println("read or write data exception");
} finally {
try {
clientSocket.close();
Util.log_debug("socket closed");
} catch (IOException ex) {
ex.printStackTrace();
}
}
}
}
使用这个方式，10个线程连续读写10000次，也就是累计访问20000万次只需要3s。
4.阻塞IO+单线程轮询+多线程处理+长连接(不可行)
多线程和长连接大大提高了效率，但是如果连接数太多，那么需要太多的线程，这样肯定不可行。这样大部分线程即使没数据也不能干其它的，就耗在这个连接上了。
我们可不可以让一个线程去负责等待这些socket，有数据了就告诉工作线程池。
代码如下，加了一个线程遍历已经连接的socket，然后如果socket.getInputStream().available() > 0就通知线程池。
<u> 这个程序有些情况下能正常工作，但是实际是有问题的，关键就在于上面的available函数是阻塞的，每次轮询所有的socket，都需要挨个等待是否已经有数据了，所以就是串行。在java里没法对socket单独设置非阻塞，必须从NIO才行，如果用C语言是可行的，但是这里不行。 </u>
package org.ifool.niodemo.redis.redis4;
import org.ifool.niodemo.redis.Util;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class RedisServer4 {
//全局缓存
public static Map<String,String> cache = new ConcurrentHashMap<String,String>();
//当前的socket
final public static Set<Socket> socketSet = new HashSet<Socket>(10);
public static void main(String[] args) throws IOException {
//用于处理请求的线程池
final ThreadPoolExecutor threadPool = new ThreadPoolExecutor(20, 1000, 30, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(1000));
ServerSocket serverSocket = new ServerSocket(8888,100);
//启动一个线程用于一直扫描可以读取数据的socket，并且去掉已经关闭的连接
Thread thread = new Thread(new Runnable() {
public void run() {
//找到可以读取的socket，处理
while (true) {
synchronized (socketSet) {
Iterator<Socket> it = socketSet.iterator();
while(it.hasNext()) {
Socket socket = it.next();
if (socket.isConnected()) {
try {
if (!socket.isInputShutdown() && socket.getInputStream().available() > 0) {
it.remove();
threadPool.execute(new RequestHandler(socket));
}
} catch (IOException ex) {
System.out.println("socket already closed1");
socketSet.remove(socket);
try {
socket.close();
} catch (IOException e) {
System.out.println("socket already closed2");
}
}
} else {
socketSet.remove(socket);
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
}
});
thread.start();
while(true) {
//接受客户端连接请求,把新建的socket加入socketset
Socket clientSocket = null;
try {
clientSocket = serverSocket.accept();
Util.log_debug("client address:" + clientSocket.getRemoteSocketAddress().toString());
synchronized (socketSet) {
socketSet.add(clientSocket);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
class RequestHandler implements Runnable{
private Socket clientSocket;
public RequestHandler(Socket socket) {
clientSocket = socket;
}
public void run() {
byte[] buffer = new byte[512];
//读取数据并且操作缓存,然后写回数据
try {
//读数据
InputStream in = clientSocket.getInputStream();
int len = in.read(); //读取长度
if(len == -1) {
throw new IOException("socket closed by client");
}
int bytesRead = in.read(buffer, 0, len);
int totalBytesRead = 0;
while (totalBytesRead < len) {
totalBytesRead += bytesRead;
bytesRead = in.read(buffer, totalBytesRead, len - totalBytesRead);
}
//操作缓存
byte[] response = Util.proce***equest(RedisServer4.cache,buffer, totalBytesRead,true);
Util.log_debug("response:" + new String(response));
//写回数据
OutputStream os = clientSocket.getOutputStream();
os.write(response);
os.flush();
synchronized (RedisServer4.socketSet) {
RedisServer4.socketSet.add(clientSocket);
}
} catch (IOException e) {
e.printStackTrace();
System.out.println("read or write data exception");
} finally {
}
}
}
5.IO多路复用+单线程轮询+多线程处理+长连接
在上述例子中我们试图用普通socket实现类似select的功能，在Java里是不可行的，必须用NIO。我们只需要一个select函数就能轮询所有的连接是否准备好数据，准备好了就能调用线程池里的线程处理。
要使用NIO，需要了解ByteBuffer, Channel等内容，比如ByteBuffer设计的就比较麻烦，此处不再展开。
客户端代码暂时不用NIO，还是用原来的，服务端代码如下：
package org.ifool.niodemo.redis.redis5;
import org.ifool.niodemo.redis.Util;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.SyncFailedException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
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.*;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class RedisServer5 {
//全局缓存
public static Map<String,String> cache = new ConcurrentHashMap<String,String>();
public static void main(String[] args) throws IOException {
//用于处理请求的线程池
final ThreadPoolExecutor threadPool = new ThreadPoolExecutor(20, 1000, 30, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(1000));
ServerSocketChannel ssc = ServerSocketChannel.open();
ssc.socket().bind(new InetSocketAddress(8888),1000);
Selector selector = Selector.open();
ssc.configureBlocking(false); //必须设置成非阻塞
ssc.register(selector, SelectionKey.OP_ACCEPT); //serverSocket只关心accept
while(true) {
int num = selector.select();
if(num == 0) {
continue;
}
Set<SelectionKey> selectionKeys = selector.selectedKeys();
Iterator<SelectionKey> it = selectionKeys.iterator();
while(it.hasNext()) {
SelectionKey key = it.next();
it.remove();
if(key.isAcceptable()) {
SocketChannel sc = ssc.accept();
sc.configureBlocking(false); //设置成非阻塞才能监听
sc.register(key.selector(), SelectionKey.OP_READ, ByteBuffer.allocate(512) );
System.out.println("new connection");
}
if(key.isReadable()) {
SocketChannel clientSocketChannel = (SocketChannel)key.channel();
//System.out.println("socket readable");
if(!clientSocketChannel.isConnected()) {
clientSocketChannel.finishConnect();
key.cancel();
clientSocketChannel.close();
System.out.println("socket closed2");
continue;
}
ByteBuffer buffer = (ByteBuffer)key.attachment();
int len = clientSocketChannel.read(buffer);
Socket socket = clientSocketChannel.socket();
if(len == -1) {
clientSocketChannel.finishConnect();
key.cancel();
clientSocketChannel.close();
System.out.println("socket closed1");
} else {
threadPool.execute(new RequestHandler(clientSocketChannel, buffer));
}
}
}
}
}
}
class RequestHandler implements Runnable{
private SocketChannel channel;
private ByteBuffer buffer;
public RequestHandler(SocketChannel channel, Object buffer) {
this.channel = channel;
this.buffer = (ByteBuffer)buffer;
}
public void run() {
//读取数据并且操作缓存,然后写回数据
try {
int position = buffer.position();
//切换成读模式，以便把第一个字节到长度读出来
buffer.flip();
int len = buffer.get(); //读取长度
if(len > position + 1) {
buffer.position(position);
buffer.limit(buffer.capacity());
return;
}
byte[] data = new byte[len];
buffer.get(data,0,len);
//操作缓存
byte[] response = Util.proce***equest(RedisServer5.cache,data, len,true);
Util.log_debug("response:" + new String(response));
buffer.clear();
buffer.put(response);
buffer.flip();
channel.write(buffer);
buffer.clear();
} catch (IOException e) {
System.out.println("read or write data exception");
} finally {
}
}
}
自己写NIO程序有很多坑，上面的代码有时候会出问题，有些异常没处理好。但是10个线程不停写10000次也是3s多。
IO多路复用+Netty
使用java的原生NIO写程序很容易出问题，因为API比较复杂，而且有很多异常要处理，比如连接的关闭，粘包半包等，使用Netty这种成熟的框架会比较好写。
Netty常用的线程模型如下图所示，mainReactor负责监听server socket，accept新连接，并将建立的socket分派给subReactor。subReactor负责多路分离已连接的socket，读写网络数据，对业务处理功能，其扔给worker线程池完成。通常，subReactor个数上可与CPU个数等同。
客户端代码如下所示。其中的两个NioEventLoop就是上面的mainReactor和subReactor。第一个参数为0，是使用默认线程数的意思，这样mainReactor一般是1个，subReactor一般与CPU核相通。
我们这里只有boss(mainReactor)和worker(subReactor)，一般情况下，还有一个线程池，用于处理真正的业务逻辑，因为worker是用来读取和解码数据的，如果在这个worker里处理业务逻辑，比如访问数据库，是不合适的。只是我们这个场景就类似于Redis，所以没有用另一个线程池。
package org.ifool.niodemo.redis.redis6;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.LengthFieldBasedFrameDecoder;
import org.ifool.niodemo.redis.Util;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.Map;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
public class RedisServer6 {
//全局缓存
public static Map<String,String> cache = new ConcurrentHashMap<String,String>();
public static void main(String[] args) throws IOException, InterruptedException {
//用于处理accept事件的线程池
EventLoopGroup bossGroup = new NioEventLoopGroup(0, new ThreadFactory() {
AtomicInteger index = new AtomicInteger(0);
public Thread newThread(Runnable r) {
return new Thread(r,"netty-boss-"+index.getAndIncrement());
}
});
//用于处理读事件的线程池
EventLoopGroup workerGroup = new NioEventLoopGroup(0, new ThreadFactory() {
AtomicInteger index = new AtomicInteger(0);
public Thread newThread(Runnable r) {
return new Thread(r,"netty-worker-"+index.getAndIncrement());
}
});
ServerBootstrap bootstrap = new ServerBootstrap();
bootstrap.group(bossGroup,workerGroup)
.channel(NioServerSocketChannel.class)
.option(ChannelOption.SO_BACKLOG,50)
.childHandler(new ChildChannelHandler());
ChannelFuture future = bootstrap.bind(8888).sync();
future.channel().closeFuture().sync();
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}
}
/**这个类就是供netty-worker调用的**/
class ChildChannelHandler extends ChannelInitializer<SocketChannel> {
protected void initChannel(SocketChannel socketChannel) throws Exception {
//先通过一个LengthFieldBasedFrameDecoder分包，再传给RequestHandler
socketChannel.pipeline()
.addLast(new RedisDecoder(127,0,1))
.addLast(new RequestHandler());
}
}
class RequestHandler extends ChannelInboundHandlerAdapter {
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
ByteBuf buf = (ByteBuf)msg;
int len = buf.readableBytes() - 1;
int lenField = buf.readByte();
if(len != lenField) {
ByteBuf resp = Unpooled.copiedBuffer("2|bad cmd".getBytes());
ctx.write(resp);
}
byte[] req = new byte[len];
buf.readBytes(req,0,len);
byte[] response = Util.proce***equest(RedisServer6.cache,req,len,true);
ByteBuf resp = Unpooled.copiedBuffer(response);
ctx.write(resp);
}
@Override
public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
ctx.flush();
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
ctx.close();
}
}
class RedisDecoder extends LengthFieldBasedFrameDecoder {
public RedisDecoder(int maxFrameLength, int lengthFieldOffset, int lengthFieldLength) {
super(maxFrameLength, lengthFieldOffset, lengthFieldLength);
}
}
可以看到，运行后产生了一个boss线程和10个worker线程。
用netty写的就比较稳定了，10个写成不停写10000次也是3秒，但是不用担心线程数了。
总结
网络IO模型只看概念什么的很难理解，只有通过实例才能理解的更深刻。我们通过回答一个问题来总结一下：
为什么redis能通过单线程实现上万的tps？
我们把redis处理请求的过程细化：
(1)读取原始数据
(2)解析并处理数据(处理业务逻辑)
(3)写会返回数据
读取数据是通过IO多路复用实现，而在底层，是通过epoll实现，epoll相比于select(不是Java NIO的select，是Linux的select)主要有以下两个优点：
一是提高了遍历socket的效率，即时有上百万个连接，它也只会遍历有事件的连接，而select需要全部遍历一遍。
二是通过mmap实现了内核态与用户态的共享内存，也就是数据从网卡到达复制到内核空间，不需要复制到用户空间了，所以使用epoll，如果发现有读事件，那么内存里的数据也准备好了，不需要拷贝。
通过以上可以得出，读取数据是十分快的。
接下来就是处理数据，这才是能使用单线程的本质原因。redis的业务逻辑是纯内存操作，耗时是纳秒级的，所以事件可以忽略不计。假如我们是一个复杂的web应用，业务逻辑涉及到读数据库，调用其它模块，那么是不能用单线程的。
同样，写数据也是通过epoll共享内存，只要把结果计算后放到用户内存，然后通知操作系统就可以了。
所以，redis能单线程支撑上万tps的前提就是每个请求都是内存操作，事件都特别短，但凡有一次请求慢了，就会导致请求阻塞。假设99.99%的请求响应时间都在1ms以内，而0.01%的请求时间为1s，那么单线程模型在处理1s请求的时候，剩余1ms的请求也都得排队。
正文到此结束
- 本文标签： 博客 NIO tomcat进程 equals rand 协议 网卡 sql Bootstrap TCP 实例 总结 http executor id ConcurrentHashMap HashSet 服务器 ip cat IDE 设计模式 Select final DDL cache 服务端 HashMap 并发 web tomcat 进程 redis 时间 DOM 锁 src Atom mmap 回答 stream java db 线程 数据 代码 遍历 操作系统 client queue 短连接 Keep-Alive Reactor linux remote 数据库 调试 多线程 解析 参数 线程池 长连接 本质 缓存 端口 tar UI Netty App 快的 Connection IOS HTTP协议 bug 连接池 cmd 配置 API CTO value ThreadPoolExecutor ACE IO 模型 synchronized tab https map 管理 空间 key 同步
- 版权声明： 本文为互联网转载文章，出处已在文章中说明(部分除外)。如果侵权，请联系本站长删除，谢谢。
- 本文海报： 生成海报一 生成海报二
热门推荐
相关文章
近期评论
-
文章和留言都翻到11页了 没有OOM
-
-
朋友，翻页到11页，及以后，会出现OOM，无法访问
-
-
搞个gitee的项目
-
-
版本号是多少，你可以下载哪个代码仓库，jdk选1.8 直接跑就行
-
-
-
Loading...
![[HBLOG]公众号](https://www.liuhaihua.cn/img/qrcode_gzh.jpg)
