1. BIO

1.1 MySocketBIOv1

  1. import java.io.BufferedReader;
  2. import java.io.IOException;
  3. import java.io.InputStream;
  4. import java.io.InputStreamReader;
  5. import java.net.ServerSocket;
  6. import java.net.Socket;
  8. public class MySocketBIOv1 {
  9.     public static void main(String[] args) throws IOException {
  10.         //开启9000端口的监听
  11.         ServerSocket serverSocket = new ServerSocket(9000, 20);
  12.         System.out.println("已开启9000端口监听");
  14.         //程序会卡死阻塞，直到有新的TCP进来。
  15.         Socket client = serverSocket.accept();
  16.         System.out.println("接收到一个新的连接:"+client.getRemoteSocketAddress());
  18.         InputStream inputStream = client.getInputStream();
  19.         //用buffer缓冲区读，读的快一点
  20.         BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
  21.         for (;;){
  22.             String dataLine = reader.readLine(); //读取一行数据
  23.             if (dataLine != null) {
  24.                 System.out.println("读取到客户端一行数据："+dataLine);//打印
  25.             }else {
  26.                 System.out.println("客户端已关闭");
  27.                 client.close();
  28.                 break;
  29.             }
  30.         }
  31.     }
  32. }

好了。启动！然后使用linux的nc连接

  1. wangfan@ubuntu:~/桌面$ nc 192.168.235.1 9000
  2. wangfan@ubuntu:~/桌面$ nc 192.168.235.1 9000
  3. 111
  4. 222
  5. 333
  6. 444
  7. 555
  8. 666
  9. 777
  10. ^C
  11. wangfan@ubuntu:~/桌面$

项目打印：

已开启9000端口监听接收到一个新的连接:/192.168.235.137:49122 读取到客户端一行数据：111 读取到客户端一行数据：222 读取到客户端一行数据：333 读取到客户端一行数据：444 读取到客户端一行数据：555 读取到客户端一行数据：666 读取到客户端一行数据：777 客户端已关闭

上面的代码只能有一个客户端连接，使用完就关闭了。 下面这个会支持多个客户端连接进来。

1.2 MySocketBIOv2

  1. import java.io.BufferedReader;
  2. import java.io.IOException;
  3. import java.io.InputStream;
  4. import java.io.InputStreamReader;
  5. import java.net.ServerSocket;
  6. import java.net.Socket;
  8. public class MySocketBIOv2 {
  9.     public static void main(String[] args) throws IOException {
  10.         //开启9000端口的监听
  11.         ServerSocket serverSocket = new ServerSocket(9000, 20);
  12.         System.out.println("已开启9000端口监听");
  14.         for (;;){
  15.             //程序会卡死阻塞，直到有新的TCP进来。
  16.             Socket client = serverSocket.accept();
  17.             System.out.println("接收到一个新的连接:"+client.getRemoteSocketAddress());
  18.             InputStream inputStream = client.getInputStream();
  19.             //用buffer缓冲区读，读的快一点
  20.             BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
  21.             for (;;){
  22.                 String dataLine = reader.readLine(); //读取一行数据
  23.                 if (dataLine != null) {
  24.                     System.out.println("读取到客户端一行数据："+dataLine);
  25.                 }else {
  26.                     System.out.println("客户端已关闭");
  27.                     client.close();
  28.                     break;
  29.                 }
  30.             }
  31.         }
  32.     }
  33. }

好了。启动！然后使用linux的nc连接

  1. wangfan@ubuntu:~/桌面$ nc 192.168.235.1 9000
  2. 111
  3. 222
  4. ^C
  5. wangfan@ubuntu:~/桌面$ nc 192.168.235.1 9000
  6. 333
  7. 444
  8. ^C
  9. wangfan@ubuntu:~/桌面$ nc 192.168.235.1 9000
  10. 555
  11. 666
  12. ^C
  13. wangfan@ubuntu:~/桌面$

项目打印：

已开启9000端口监听接收到一个新的连接:/192.168.235.137:49140 读取到客户端一行数据：111 读取到客户端一行数据：222 客户端已关闭 接收到一个新的连接:/192.168.235.137:49142 读取到客户端一行数据：333 读取到客户端一行数据：444 客户端已关闭 接收到一个新的连接:/192.168.235.137:49144 读取到客户端一行数据：555 读取到客户端一行数据：666 客户端已关闭

好了，可以支持多个客户端了，但是还有一个弊端，就是，连接进来的只能是顺序的，加上前面的客户端一直不断开，那么后面的客户端就要永远排队。所以。我们是用多线程再次改进。

1.3 MySocketBIOv3

  1. import java.io.BufferedReader;
  2. import java.io.IOException;
  3. import java.io.InputStream;
  4. import java.io.InputStreamReader;
  5. import java.net.ServerSocket;
  6. import java.net.Socket;
  8. public class MySocketBIOv3 {
  9.     public static void main(String[] args) throws IOException {
  10.         //开启9000端口的监听
  11.         ServerSocket serverSocket = new ServerSocket(9000, 20);
  12.         System.out.println("已开启9000端口监听");
  14.         for (;;){
  15.             //程序会卡死阻塞，直到有新的TCP进来。
  16.             Socket client = serverSocket.accept();
  17.             new Thread(()->{
  18.                 System.out.println("接收到一个新的连接:"+client.getRemoteSocketAddress());
  19.                 InputStream inputStream = null;
  20.                 try {
  21.                     inputStream = client.getInputStream();
  22.                     //用buffer缓冲区读，读的快一点
  23.                     BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
  24.                     for (;;){
  25.                         String dataLine = reader.readLine(); //读取一行数据
  26.                         if (dataLine != null) {
  27.                             System.out.println("读取到客户端"+client.getRemoteSocketAddress()+"一行数据："+dataLine);
  28.                         }else {
  29.                             //读取不到则为客户端关闭
  30.                             System.out.println("客户端"+client.getRemoteSocketAddress()+"已关闭");
  31.                             client.close();
  32.                             break;
  33.                         }
  34.                     }
  35.                 } catch (IOException e) {
  36.                     e.printStackTrace();
  37.                 }
  38.             }).start();
  39.         }
  40.     }
  41. }

好了。启动！然后使用linux的nc连接

  1. wangfan@ubuntu:~/桌面$ nc 192.168.235.1 9000
  2. 111
  3. 222
  4. ^C
  5. wangfan@ubuntu:~/桌面$

再打开一个标签，再次连接

  1. wangfan@ubuntu:~/桌面$ nc 192.168.235.1 9000
  2. 333
  3. 444
  4. ^C
  5. ^C
  6. wangfan@ubuntu:~/桌面$

项目打印：

已开启9000端口监听接收到一个新的连接:/192.168.235.137:49152 读取到客户端/192.168.235.137:49152一行数据：111 读取到客户端/192.168.235.137:49152一行数据：222 接收到一个新的连接:/192.168.235.137:49154 读取到客户端/192.168.235.137:49154一行数据：333 读取到客户端/192.168.235.137:49154一行数据：444 读取到客户端/192.168.235.137:49154一行数据： 客户端/192.168.235.137:49154已关闭 客户端/192.168.235.137:49152已关闭

好了。BIO最多只能通过多线程支持到这种程度了，不能做更进一步的优化了。但是BIO的缺陷已经显露出来了。

BIO的缺陷：
因为接收TCP握手以及握手成功后接收数据是阻塞操作，也就是上面的serverSocket.accept();和 reader.readLine();。所以系统不得不启用多线程处理，但是这样随着客户端连接数量越来越大。系统启动的多线程越来越多，cpu大部分时间消耗在线程之间切换上。严重浪费资源。

归根到底：BIO的根本缺陷在于它有2个是阻塞操作。即：接收到连接的阻塞，和接收数据的阻塞。

2. NIO

为解决BIO的阻塞操作的原因造成系统资源严重浪费，Linux的kernel推出了NIO的API。
即调用serverSocket.accept();和reader.readLine(); 这两个API时不再是“接收”的意思，而是“询问”的意思。 即有连接/数据就会有返回，没有则返回无。 这样线程不用卡住。

2.1 MySocketNIOv1

  1. import java.io.IOException;
  2. import java.net.InetSocketAddress;
  3. import java.nio.ByteBuffer;
  4. import java.nio.channels.ServerSocketChannel;
  5. import java.nio.channels.SocketChannel;
  7. public class MySocketNIOv1 {
  8.     public static void main(String[] args) throws IOException {
  9.         //开启9000端口的监听并设置为非阻塞
  10.         ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
  11.         serverSocketChannel.bind(new InetSocketAddress(9000));
  12.         //设置为非阻塞。重点！！！！！
  13.         serverSocketChannel.configureBlocking(false);
  14.         System.out.println("已开启9000端口监听...");
  16.         //不断轮询接收客户端连接
  17.         for (;;){
  18.             //接受客户端的连接，而且这一步不阻塞，如果没有客户端连接进来，则client会返回null
  19.             SocketChannel client = serverSocketChannel.accept();//不会阻塞？  -1 NULL
  20.             if (client != null) {
  21.                 new Thread(()->{
  22.                     try {
  23.                         System.out.println("接收到一个新的连接:"+client.getRemoteAddress().toString());
  24.                         //重点！！！！客户端已连接成功，设置接收数据不阻塞
  25.                         client.configureBlocking(false);
  26.                         //不断轮询接收客户端发过来的数据
  27.                         for (;;){
  28.                             ByteBuffer buffer = ByteBuffer.allocateDirect(4096);
  29.                             int readBytesNum = client.read(buffer);
  30.                             //读取数据
  31.                             if ( readBytesNum > 0 ){
  32.                                 buffer.flip();
  33.                                 byte[] readDataBytes = new byte[buffer.limit()];
  34.                                 buffer.get(readDataBytes);
  35.                                 String readData = new String(readDataBytes);
  36.                                 System.out.println("读取到客户端"+client.getRemoteAddress()+"一行数据："+readData);
  37.                                 buffer.clear();
  38.                             }else  if (readBytesNum == -1){//客户端关闭
  39.                                 System.out.println("客户端"+client.getRemoteAddress()+"已关闭");
  40.                                 client.close();
  41.                                 break;
  42.                             }
  43.                         }
  44.                     } catch (IOException e) {
  45.                         e.printStackTrace();
  46.                     }
  47.                 }).start();
  48.             }
  49.         }
  50.     }
  51. }

好了。启动！然后使用linux的nc连接

  1. wangfan@ubuntu:~/桌面$ nc 192.168.235.1 9000
  2. aaa
  3. bbb
  4. ^C
  5. wangfan@ubuntu:~/桌面$

再打开一个标签，再次连接

  1. wangfan@ubuntu:~/桌面$ nc 192.168.235.1 9000
  2. ccc
  3. ddd
  4. ^C
  5. wangfan@ubuntu:~/桌面$

再打开一个标签，再次连接

  1. wangfan@ubuntu:~/桌面$ nc 192.168.235.1 9000
  2. eee
  3. fff
  4. ^C
  5. wangfan@ubuntu:~/桌面$

项目打印：

已开启9000端口监听…接收到一个新的连接:/192.168.235.137:49178 读取到客户端/192.168.235.137:49178一行数据：aaa

读取到客户端/192.168.235.137:49178一行数据：bbb

接收到一个新的连接:/192.168.235.137:49180 读取到客户端/192.168.235.137:49180一行数据：ccc

读取到客户端/192.168.235.137:49180一行数据：ddd

接收到一个新的连接:/192.168.235.137:49182 读取到客户端/192.168.235.137:49182一行数据：eee

读取到客户端/192.168.235.137:49182一行数据：fff

客户端/192.168.235.137:49182已关闭 客户端/192.168.235.137:49178已关闭 客户端/192.168.235.137:49180已关闭

2.2 MySocketNIOv2

  1. import java.io.IOException;
  2. import java.net.InetSocketAddress;
  3. import java.nio.ByteBuffer;
  4. import java.nio.channels.ServerSocketChannel;
  5. import java.nio.channels.SocketChannel;
  6. import java.util.Iterator;
  7. import java.util.LinkedList;
  9. public class MySocketNIOv2 {
  11.     public static void main(String[] args) throws IOException {
  13.         //使用LinkedList收集所有已建立连接的客户端
  14.         LinkedList<SocketChannel> clients = new LinkedList<>();
  16.         //开启9000端口的监听并设置为非阻塞
  17.         ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
  18.         serverSocketChannel.bind(new InetSocketAddress(9000));
  19.         //设置为非阻塞。重点！！！！！
  20.         serverSocketChannel.configureBlocking(false);
  21.         System.out.println("已开启9000端口监听...");
  23.         //起新线程不断轮询接收客户端连接
  24.         new Thread(()->{
  25.             for (;;){
  26.                 try {
  27.                     synchronized (MySocketNIOv2.class){
  28.                         //接受客户端的连接，而且这一步不阻塞，如果没有客户端连接进来，则client会返回null
  29.                         SocketChannel client = serverSocketChannel.accept();
  30.                         if (client != null) {
  31.                             System.out.println("接收到一个新的连接:"+client.getRemoteAddress().toString());
  32.                             //重点！！！！客户端已连接成功，设置接收数据不阻塞
  33.                             client.configureBlocking(false);
  34.                             //不断轮询接收客户端发过来的数据
  35.                             clients.add(client);
  36.                         }
  37.                     }
  38.                 } catch (IOException e) {
  39.                     e.printStackTrace();
  40.                 }
  41.             }
  42.         }).start();
  44.         //起新线程不断轮询clients，从里面拿数据
  45.         new Thread(()->{
  46.             //不断轮询clients
  47.             for (;;){
  48.                 synchronized (MySocketNIOv2.class){
  49.                     Iterator<SocketChannel> iterator = clients.iterator();
  50.                     while (iterator.hasNext()){
  51.                         SocketChannel client = iterator.next();
  52.                         //不断轮询接收客户端发过来的数据
  53.                         for (;;){
  54.                             try {
  55.                                 //开辟一个4096字节的buffer
  56.                                 ByteBuffer buffer = ByteBuffer.allocateDirect(4096);
  57.                                 int readBytesNum = client.read(buffer);
  58.                                 if ( readBytesNum > 0 ){
  59.                                     buffer.flip();
  60.                                     byte[] readDataBytes = new byte[buffer.limit()];
  61.                                     buffer.get(readDataBytes);
  62.                                     String readData = new String(readDataBytes);
  63.                                     System.out.println("读取到客户端"+client.getRemoteAddress()+"一行数据："+readData);
  64.                                     buffer.clear();
  65.                                 }else  if (readBytesNum == -1){
  66.                                     System.out.println("客户端"+client.getRemoteAddress()+"已关闭");
  67.                                     client.close();
  68.                                     iterator.remove();
  69.                                     break;
  70.                                 }
  71.                             } catch (IOException e) {
  72.                                 e.printStackTrace();
  73.                             }
  74.                         }
  75.                     }
  76.                 }
  77.             }
  78.         }).start();
  80.         System.in.read();
  81.     }
  82. }

好了。启动！然后使用linux的nc连接

  1. [root@192 ~]# nc 192.168.235.1 9000
  2. 123
  3. 234
  4. 345
  5. 456
  6. 567
  7. ^C
  8. [root@192 ~]#

项目打印：

已开启9000端口监听…接收到一个新的连接:/192.168.235.133:36198 读取到客户端/192.168.235.133:36198一行数据：123

读取到客户端/192.168.235.133:36198一行数据：234

读取到客户端/192.168.235.133:36198一行数据：345

读取到客户端/192.168.235.133:36198一行数据：456

读取到客户端/192.168.235.133:36198一行数据：567

客户端/192.168.235.133:36198已关闭

上面是优化后的NIO模型，这个模型放弃了一个连接建立一个线程的方式，而是使用两个线程，一个线程不断接收客户端连接，接收到的客户端放入到一个链表里面，另一个线程不断轮询链表内的客户端，从客户端里面读数据。
MySocketNIOv2看似解决了多线程的问题，但是遇到另外一个新的问题。那就是， LinkedList里面的元素都是排队取数据的，假设其中一个的数据很多，取出数据很慢，这样会阻塞其他客户端取出数据。所以这个时候我们可以把有数据到达的客户端启抛出一个线程单独处理数据的读取。

2.3 MySocketNIOv3

  1. import java.io.IOException;
  2. import java.net.InetSocketAddress;
  3. import java.nio.ByteBuffer;
  4. import java.nio.channels.ServerSocketChannel;
  5. import java.nio.channels.SocketChannel;
  6. import java.util.Iterator;
  7. import java.util.LinkedList;
  9. public class MySocketNIOv3 {
  11.     public static void main(String[] args) throws IOException {
  13.         //使用LinkedList收集所有已建立连接的客户端
  14.         LinkedList<SocketChannel> clients = new LinkedList<>();
  16.         //开启9000端口的监听并设置为非阻塞
  17.         ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
  18.         serverSocketChannel.bind(new InetSocketAddress(9000));
  19.         //设置为非阻塞。重点！！！！！
  20.         serverSocketChannel.configureBlocking(false);
  21.         System.out.println("已开启9000端口监听...");
  23.         //起新线程不断轮询接收客户端连接
  24.         new Thread(()->{
  25.             for (;;){
  26.                 try {
  27.                     synchronized (MySocketNIOv3.class){
  28.                         //接受客户端的连接，而且这一步不阻塞，如果没有客户端连接进来，则client会返回null
  29.                         SocketChannel client = serverSocketChannel.accept();
  30.                         if (client != null) {
  31.                             System.out.println("接收到一个新的连接:"+client.getRemoteAddress().toString());
  32.                             //重点！！！！客户端已连接成功，设置接收数据不阻塞
  33.                             client.configureBlocking(false);
  34.                             //不断轮询接收客户端发过来的数据
  35.                             clients.add(client);
  36.                         }
  37.                     }
  38.                 } catch (IOException e) {
  39.                     e.printStackTrace();
  40.                 }
  41.             }
  42.         }).start();
  44.         //起新线程不断轮询clients，从里面拿数据
  45.         new Thread(()->{
  46.             //不断轮询clients
  47.             for (;;){
  48.                 synchronized (MySocketNIOv3.class){
  49.                     Iterator<SocketChannel> iterator = clients.iterator();
  50.                     while (iterator.hasNext()){
  51.                         SocketChannel client = iterator.next();
  52.                         if (!client.isConnected()){
  53.                             iterator.remove();
  54.                         }
  55.                         //不断轮询接收客户端发过来的数据
  56.                         for (;;){
  57.                             try {
  58.                                 //开辟一个4096字节的buffer
  59.                                 ByteBuffer buffer = ByteBuffer.allocateDirect(4096);
  60.                                 String data = MySocketNIOv3.readDataFromClient(buffer, client);
  61.                                 if (data == null){
  62.                                     System.out.println("客户端"+client.getRemoteAddress()+"已关闭");
  63.                                     client.close();
  64.                                     iterator.remove();
  65.                                     break;
  66.                                 }
  67.                                 if (!data.equals("")){
  68.                                     String finalData = data;
  69.                                     new Thread(()->{
  70.                                         try {
  71.                                             System.out.println("读取到客户端"+client.getRemoteAddress()+"一行数据："+ finalData);
  72.                                             while (true){
  73.                                                 buffer.flip();
  74.                                                 String data1 = MySocketNIOv3.readDataFromClient(buffer, client);
  75.                                                 if (data1 == null){
  76.                                                     System.out.println("客户端"+client.getRemoteAddress()+"已关闭");
  77.                                                     client.close();
  78.                                                     break;
  79.                                                 }else if (!data1.equals("")){
  80.                                                     System.out.println("读取到客户端"+client.getRemoteAddress()+"一行数据："+ data1);
  81.                                                 }
  82.                                             }
  83.                                         } catch (IOException e) {
  84.                                             e.printStackTrace();
  85.                                         }
  87.                                     }).start();
  88.                                 }
  89.                             } catch (IOException e) {
  90.                                 e.printStackTrace();
  91.                             }
  92.                         }
  93.                     }
  94.                 }
  95.             }
  96.         }).start();
  98.         System.in.read();
  99.     }
  102.     public static String readDataFromClient(ByteBuffer buffer,SocketChannel client){
  103.         try {
  104.             int readBytesNum = client.read(buffer);
  105.             if (readBytesNum > 0){
  106.                 buffer.flip();
  107.                 byte[] readDataBytes = new byte[buffer.limit()];
  108.                 buffer.get(readDataBytes);
  109.                 String readData = new String(readDataBytes);
  110.                 buffer.clear();
  111.                 return readData;
  112.             }
  113.             if (readBytesNum == -1){
  114.                 return null;
  115.             }else {
  116.                 return "";
  117.             }
  118.         } catch (IOException e) {
  119.             e.printStackTrace();
  120.             return null;
  121.         }
  122.     }
  123. }
  1. import java.net.InetSocketAddress;
  2. import java.nio.ByteBuffer;
  3. import java.nio.channels.ServerSocketChannel;
  4. import java.nio.channels.SocketChannel;
  5. import java.util.LinkedList;
  7. public class SocketNIO {
  9.     public static void main(String[] args) throws Exception {
  11.         //所有连接进来的客户端的集合
  12.         LinkedList<SocketChannel> clients = new LinkedList<>();
  14.         ServerSocketChannel ss = ServerSocketChannel.open();  //服务端开启监听：接受客户端
  15.         ss.bind(new InetSocketAddress(9090));
  16.         //设置为NONBLOCKING，不阻塞。
  17.         ss.configureBlocking(false); //重点  OS  NONBLOCKING!!!  //只让接受客户端  不阻塞
  18.         //不断轮询接收客户端连接
  19.         while (true) {
  20.             //接受客户端的连接，而且这一步不阻塞，如果没有客户端连接进来，则client会返回null
  21.             SocketChannel client = ss.accept(); //不会阻塞？  -1 NULL
  22.             if (client == null) {
  23.                 //System.out.println("没有客户端连接进来..");
  24.             } else {
  25.                 //客户端已连接成功，设置接收数据不阻塞
  26.                 client.configureBlocking(false); //重点  socket（服务端的listen socket<连接请求三次握手后，往我这里扔，我去通过accept 得到  连接的socket>，连接socket<连接后的数据读写使用的> ）
  27.                 int port = client.socket().getPort();   //客户端的端口号
  28.                 System.out.println("client..port: " + port);
  29.                 clients.add(client);
  30.             }
  31.             ByteBuffer buffer = ByteBuffer.allocateDirect(4096);  //可以在堆里   堆外
  32.             //遍历已经链接进来的客户端能不能读写数据
  33.             for (SocketChannel c : clients) {   //串行化！！！！  多线程！！
  34.                 int num = c.read(buffer);  // >0  -1  0   //不会阻塞
  35.                 if (num > 0) {
  36.                     buffer.flip();
  37.                     byte[] aaa = new byte[buffer.limit()];
  38.                     buffer.get(aaa);
  39.                     String b = new String(aaa);
  40.                     System.out.println(c.socket().getPort() + " : " + b);
  41.                     buffer.clear();
  42.                 }
  43.             }
  44.         }
  45.     }
  46. }

这样的不阻塞操作可以让线程不在浪费，只使用一个线程即可遍历所有连接进来的client。并读写数据。
但是这样的模型，如果遇到客户端数量再一次增加一个量级的客户端连接，依然不够用， 如果遇到C10K的问题。每次一循环就要，循环10000次，而且由于客户端的read操作都是一次用户态向内核态的切换，每循环一次就是10000次切换，这对于系统来说损失很大造成的资源浪费。

NIO模型的最大根本弊端在于：用户态和内核态的切换过于频繁，导致的性能下降。多路复用技术就是解决这个问题。

3. 多路复用

多路复用说的是：select、poll以及epoll的集合。也就是说：select、poll以及epoll都属于多路复用。

3.1 select

3.2 poll

3.3 epoll