NIO 实现非阻塞 Socket 通讯

NIO 实现多人聊天室的案例
服务端

1. import java.io.IOException;
2. import java.net.InetSocketAddress;
3. import java.nio.ByteBuffer;
4. import java.nio.channels.*;
5. import java.nio.charset.Charset;
7. /**
8. * 聊天室服务端
9. */
10. public class NServer {
12.     private Selector selector = null;
14.     static final int PORT = 30000;
16.     private Charset charset = Charset.forName("UTF-8");
18.     ServerSocketChannel server = null;
20.     public void init() throws IOException {
21.         selector = Selector.open();
22.         server = ServerSocketChannel.open();
23.         InetSocketAddress isa = new InetSocketAddress("127.0.0.1", PORT);
24.         // 将该 ServerSocketChannel 绑定到指定 IP 地址
25.         server.bind(isa);
27.         //设置为以非阻塞方式工作
28.         server.configureBlocking(false);
29.         // 将 server 注册到指定的 Selector
30.         server.register(selector, SelectionKey.OP_ACCEPT);
32.         while (selector.select() > 0) {
33.             for (SelectionKey sk : selector.selectedKeys()) {
34.                 // 从 selector 上的已选择 Key 集中删除正在处理的 SelectionKey
35.                 selector.selectedKeys().remove(sk);
36.                 // 如果 sk 对应 channel 包含客户端的连接请求
37.                 if (sk.isAcceptable()) {
38.                     // 接受请求
39.                     SocketChannel sc = server.accept();
40.                     // 采用非阻塞模式
41.                     sc.configureBlocking(false);
42.                     // 将该 SocketChannel 也注册到 selector
43.                     sc.register(selector, SelectionKey.OP_READ);
44.                     // 将 sk 对应的 channel 设置成准备接受其他请求
45.                     sk.interestOps(SelectionKey.OP_ACCEPT);
46.                 }
47.                 // 如果 sk 对应的channel 有数据需要读取
48.                 if (sk.isReadable()) {
49.                     SocketChannel sc = (SocketChannel) sk.channel();
50.                     ByteBuffer buffer = ByteBuffer.allocate(1024);
51.                     String content = "";
53.                     try {
54.                         // 读取数据操作
55.                         while (sc.read(buffer) > 0) {
56.                             buffer.flip();
57.                             content += charset.decode(buffer);
58.                         }
59.                         System.out.println("读取的数据： " + content);
60.                         sk.interestOps(SelectionKey.OP_READ);
61.                     } catch (IOException e) {
62.                         sk.cancel();
63.                         if (sk.channel() != null) {
64.                             sk.channel().close();
65.                         }
66.                     }
67.                     // 如果 content 的长度大于 0，即聊天信息不为空
68.                     if (content.length() > 0) {
69.                         // 遍历该 selector 里注册的所有 SelectionKey
70.                         for (SelectionKey key : selector.keys()) {
71.                             // 获取 channel
72.                             Channel targetChannel = key.channel();
73.                             // 如果该 channel 是 SocketChannel
74.                             if (targetChannel instanceof SocketChannel) {
75.                                 // 将读到的内容写到该 channel 中
76.                                 SocketChannel dest = (SocketChannel) targetChannel;
77.                                 dest.write(charset.encode(content));
78.                             }
79.                         }
80.                     }
81.                 }
82.             }
83.         }
85.     }
87.     public static void main(String[] args) throws IOException {
88.         new NServer().init();
89.     }
91. }

复制代码

启动时建立一个可监听连接请求的 ServerSocketChannel，并注册到 Selector，接着直接采用循环不断监听 Selector 对象的 select() 方法返回值，大于0时，处理该 Selector 上所有被选择的 SelectionKey。
服务端仅需监听两种操作：连接和读取数据。
处理连接操作时，只需将连接完成后产生的 SocketChannel 注册到指定的 Selector 对象；
处理读取数据时，先从该 Socket 中读取数据，再将数据写入 Selector 上注册的所有 Channel 中。

客户端

1. import java.io.IOException;
2. import java.net.InetSocketAddress;
3. import java.nio.ByteBuffer;
4. import java.nio.channels.SelectionKey;
5. import java.nio.channels.Selector;
6. import java.nio.channels.SocketChannel;
7. import java.nio.charset.Charset;
8. import java.util.Scanner;
10. /**
11. * 聊天室客户端
12. */
13. public class NClient {
14.     private Selector selector = null;
15.     static final int PORT = 30000;
16.     private Charset charset = Charset.forName("UTF-8");
18.     private SocketChannel sc = null;
20.     public void init() throws IOException {
21.         selector = Selector.open();
22.         InetSocketAddress isa = new InetSocketAddress("127.0.0.1", PORT);
23.         // 打开套接字通道并将其连接到远程地址
24.         sc = SocketChannel.open(isa);
26.         // 设置为非阻塞模式
27.         sc.configureBlocking(false);
28.         // 注册到 selector
29.         sc.register(selector, SelectionKey.OP_READ);
31.         new ClientThread().start();
32.         // 创建键盘输入流
33.         Scanner scan = new Scanner(System.in);
34.         while (scan.hasNextLine()) {
35.             String line = scan.nextLine();
36.             // 将键盘大忽如的内容输出到 SocketChannel 中
37.             sc.write(charset.encode(line));
38.         }
40.     }
42.     private class ClientThread extends  Thread {
43.         @Override
44.         public void run() {
45.             try {
46.                 while (selector.select() > 0) {
47.                     for (SelectionKey sk : selector.selectedKeys()) {
48.                         // 从 set集合删除正在处理的 SelectionKey
49.                         selector.selectedKeys().remove(sk);
50.                         // 如果 sk 对应的 channel 中有可读数据
51.                         if (sk.isReadable()) {
52.                             // 使用 NIO 读取 channel 中的数据
53.                             SocketChannel sc = (SocketChannel) sk.channel();
54.                             ByteBuffer buff = ByteBuffer.allocate(1024);
55.                             String content = "";
56.                             while (sc.read(buff) > 0) {
57.                                 sc.read(buff);
58.                                 buff.flip();
59.                                 content += charset.decode(buff);
60.                             }
61.                             System.out.println("聊天信息： " + content);
62.                             // 为下一次读取做准备
63.                             sk.interestOps(SelectionKey.OP_READ);
64.                         }
65.                     }
66.                 }
67.             } catch (IOException e) {
68.                 e.printStackTrace();
69.             }
70.         }
71.     }
73.     public static void main(String[] args) throws IOException {
74.         new NClient().init();
75.     }
76. }

复制代码

 

相比于服务端程序，客户端要简单一些，只有一个 SocketChannel ，将其注册到指定的 Selector 后，程序启动另一个线程来监听该 Selector 即可。

分别启动两个程序后，可以在客户点输入内容，在服务端就可以读取到输入的内

 
服务端内容：

 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！