java的基于NIO的socketChannel（无阻塞IO）

Server：

package SocketTest;


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.Calendar;
import java.util.Iterator;

public class NIOServer {
    ServerSocketChannel server;
    Selector selector;
    NIOServer(String address,int port) throws IOException {
        this.server=ServerSocketChannel.open(); //服务初始化
        this.server.configureBlocking(false);  // 设置为非阻塞
        this.server.bind(new InetSocketAddress(address,port));  //绑定端口
        this.selector = Selector.open();
    }

    public void startServer(){
        try{
            // 注册OP_ACCEPT事件（监听该事件，如果有客户端发来连接请求，则该键在select后被选中）
            this.server.register(this.selector, SelectionKey.OP_ACCEPT);
            Calendar ca=Calendar.getInstance();
            System.out.println("server start...");
            while (true){
                this.selector.select(); //选择准备好的事件
                Iterator<SelectionKey> it=this.selector.selectedKeys().iterator(); //已选择的键集
                while (it.hasNext()){
                    SelectionKey key=it.next();
                    System.out.println("key:"+key.toString());
                    it.remove();  //处理掉后将键移除，避免重复消费(因为下次选择后，还在已选择键集中)
                    if (key.isAcceptable()){
                        SocketChannel client=this.server.accept();
                        client.configureBlocking(false);
                        client.register(this.selector,SelectionKey.OP_READ);//注册read，监听客户端发送的信息。
                        //keys为所有键，除掉server注册的键就是已连接socketChannel的数量
                        String message="连接成功，第"+(this.selector.keys().size()-1)+"个用户";
                        client.write(ByteBuffer.wrap(message.getBytes()));  //向客户端发送信息
                        InetSocketAddress address=(InetSocketAddress)client.getRemoteAddress();
                        System.out.println(ca.getTime()+"\t"+address.getHostName()+":"+address.getPort()+"\t");
                        System.out.println("客户端已经连接...");
                    }
                    if(key.isReadable()){
                        SocketChannel client=(SocketChannel)key.channel();
                        InetSocketAddress address=(InetSocketAddress)client.getRemoteAddress();
                        System.out.println(ca.getTime()+"\t"+address.getHostName()+":"+address.getPort());;
                        ByteBuffer bf=ByteBuffer.allocate(1024*4);
                        int len=0;
                        byte[]res=new byte[1024*4];
                        //捕获异常，因为在客户端关闭后会发送FIN报文，会触发read事件，但连接已关闭,此时read()会产生异常
                        try{
                            while ((len=client.read(bf))!=0){
                                bf.flip();
                                bf.get(res,0,len);
                                System.out.println("客户端发来的消息："+new String(res,0,len));
                                client.write(ByteBuffer.wrap("已收到!!!".getBytes()));
                                bf.clear();
                            }
                        }catch (IOException e){
//                            e.printStackTrace();
                            key.cancel();
                            client.close();
                            System.out.println("客户端已经断开了");
                        }
                    }
                }
            }
        }catch (Exception e){
            e.printStackTrace();
            System.out.println("服务器异常，已经关闭...");
        }
    }
    public static void main(String[]args){
        try {
            NIOServer nioServer=new NIOServer("127.0.0.1",9999);
            nioServer.startServer();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

控制台监听线程：

package SocketTest;

import java.nio.ByteBuffer;
import java.nio.channels.ClosedChannelException;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Scanner;

//控制台监听线程
public class ChatThread extends Thread{
    private Selector selector;
    private SocketChannel client;
    public boolean flag=false;

    public ChatThread(Selector selector,SocketChannel client){
        super();
        this.selector=selector;
        this.client=client;
    }

    @Override
    public void run(){
        try{
            //等待连接建立
            Thread.sleep(500);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        Scanner scanner=new Scanner(System.in);
        System.out.println("输入您要发送的信息：");
        while (scanner.hasNextLine()){
            String message=scanner.nextLine();
            try {
                // 用户已经输入，注册写事件,将输入的消息发送给客户端
                this.client.register(this.selector, SelectionKey.OP_WRITE, ByteBuffer.wrap(message.getBytes()));
                // 唤醒之前因为监听OP_READ而阻塞的select（）
                this.selector.wakeup();
            }catch (ClosedChannelException e){
                e.printStackTrace();
            }
            if (message.equals("exit")){
                this.flag=true;
                break;
            }
        }
    }
}

Client：

package SocketTest;



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.SocketChannel;
import java.nio.charset.Charset;
import java.util.Calendar;
import java.util.Iterator;
import java.util.Set;

public class NIOClient {
    SocketChannel client;
    Selector selector;

    NIOClient(String address,int port) throws IOException {
        this.client=SocketChannel.open();  //初始化客户端
        this.selector=Selector.open();
        this.client.configureBlocking(false);
        this.client.register(this.selector, SelectionKey.OP_CONNECT);  //注册连接事件
        this.client.connect(new InetSocketAddress(address,port));  //发起连接
    }
    public void startClient(){
        try{
            ChatThread chatThread=new ChatThread(this.selector,this.client);  //开启控制台输入监听
            chatThread.start();
            Calendar ca=Calendar.getInstance(); //轮询处理
            while (true){
                if(chatThread.flag){
                    System.out.println("客户端关闭...");
                    break;
                }
                else if (this.client.isOpen()){
                    this.selector.select();
                    Set<SelectionKey>keys=this.selector.selectedKeys();//已选择键集
                    Iterator<SelectionKey>it = keys.iterator();
                    while (it.hasNext()){  // 处理准备就绪的事件
                        SelectionKey key=it.next();
                        it.remove();  // 删除当前的键，避免重复消费
                        if(key.isConnectable()){
                            while (!this.client.finishConnect()){
                                // 在非阻塞模式下connect也是非阻塞的，所以要确保连接已经建立完成
                                System.out.println("连接中...");
                            }
                            this.client.register(this.selector,SelectionKey.OP_READ);
                        }
                        // 控制台监听到有输入，注册OP_WRITE，然后将消息附在attachment中
                        if(key.isWritable()){
                            // 发送消息给服务器
                            System.out.println("key.attachment():"+(key.attachment()).toString());
//                            System.out.println("message:"+Charset.forName("utf-8").newDecoder().decode((ByteBuffer)key.attachment()));
                            this.client.write((ByteBuffer)key.attachment());
                        /*
                            已处理完此次输入，但OP_WRITE只要当前通道输出方向没有被占用
                            就会准备就绪，select()不会阻塞（但我们需要控制台触发,在没有输入时
                            select()需要阻塞），因此改为监听OP_READ事件，该事件只有在socket
                            有输入时select()才会返回。
                        */
                            this.client.register(this.selector,SelectionKey.OP_READ);
                            System.out.println(ca.getTime()+"  writable...");
                        }
                        // 处理输入事件
                        if(key.isReadable()){
                            ByteBuffer byteBuffer=ByteBuffer.allocate(1024*4);
                            int len=0;
                            //捕获异常，因为在服务端关闭后会发送FIN报文，会触发read事件，但连接已关闭,此时read()会产生异常
                            try {
                                if((len=this.client.read(byteBuffer))>0){
                                    System.out.println("收到来自服务器的消息："+new String(byteBuffer.array()));
                                }
                            }catch (IOException e){
                                e.printStackTrace();
                                System.out.println("服务器异常....");
                                key.cancel();
                                this.client.close();
                            }
                        }
                    }
                }
                else {
                    break;
                }
            }
        }catch (Exception e){
            e.printStackTrace();
            System.out.println("客户端异常...");
        }

    }

    public static void main(String[]args){
        try{
            NIOClient nioClient=new NIOClient("127.0.0.1",9999);
            nioClient.startClient();
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

另一个Client：

package SocketTest;

import java.io.IOException;

public class AnotherClient {
    public static void main(String[]args){
        try {
            NIOClient nioClient=new NIOClient("127.0.0.1",9999);
            nioClient.startClient();
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

Tip：内容改变自https://blog.csdn.net/weixin_42762133/article/details/100040141