Java 实现NIO网络通信

IO模型

IO模型就是说用什么样的通道进行数据的发送和接收，Java共支持3种网络编程IO模式：BIO，NIO，AIO

 

BIO

 

BIO(Blocking IO)

同步阻塞模型，一个客户端连接对应一个处理线程

 

 不难看出 BIO的劣势在于如果客户端过多  会产生很多的线程

BIO代码实例

server端

package com.io.bio;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class SocketServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(9000);
        while (true) {
            System.out.println("等待连接。。");
            //阻塞方法 accept会阻塞线程  直到有连接事件发生
            Socket clientSocket = serverSocket.accept();
            System.out.println("有客户端连接了。。");
            handler(clientSocket);

            /*new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        handler(clientSocket);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();*/
        }
    }

    private static void handler(Socket clientSocket) throws IOException {
        byte[] bytes = new byte[1024];
        System.out.println("准备read。。");
        //接收客户端的数据，阻塞方法，没有数据可读时就阻塞 一直到客户端发送消息后  跳出阻塞 执行后续的逻辑
        int read = clientSocket.getInputStream().read(bytes);
        System.out.println("read完毕。。");
        if (read != -1) {
            System.out.println("接收到客户端的数据：" + new String(bytes, 0, read));
        }
        clientSocket.getOutputStream().write("HelloClient".getBytes());
        clientSocket.getOutputStream().flush();
    }
}

 

client端

//客户端代码
public class SocketClient {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("localhost", 9000);
        //向服务端发送数据
        socket.getOutputStream().write("HelloServer".getBytes());
        socket.getOutputStream().flush();
        System.out.println("向服务端发送数据结束");
        byte[] bytes = new byte[1024];
        //接收服务端回传的数据
        socket.getInputStream().read(bytes);
        System.out.println("接收到服务端的数据：" + new String(bytes));
        socket.close();
    }
}

劣势：

　　1.accept  read 是阻塞方法  如果没有相关动作  会浪费资源

　　2.连接后，如果需要异步处理消息，过造成线程过多  服务器压力增大

应用场景：

　　BIO 方式适用于连接数目比较小且固定的架构， 这种方式对服务器资源要求比较高， 但程序简单易理解。

 

NIO(Non Blocking IO) 同步非阻塞IO

　　服务端一个线程可以处理多个连接请求，并且把这些请求都注册到多路复用器（selector）中，selector通过轮询的方式，获取到客户端相应的事件，比如accept read 

示例代码

package com.socket.nio.server;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
import java.util.Set;

public class NIOSocketServer {

    public static void main(String[] args) throws IOException {
        //创建一个serversocket通道，并且设置为非阻塞
        ServerSocketChannel socketChannel = ServerSocketChannel.open();
        //设置为非阻塞  默认是阻塞
        socketChannel.configureBlocking(false);
        //服务端绑定一个端口号  实时监听所有的客服端
        socketChannel.socket().bind(new InetSocketAddress(8888));

        //创建一个selector多路复用器  并且把serversocektchannel注册到selector中
        Selector selector = Selector.open();
        //注册serversocketchannel到selector  并且告知selector当前这个serversocketchannel 对连接感兴趣
        socketChannel.register(selector, SelectionKey.OP_ACCEPT);

        //循环监听处理客户端事件
        while (true) {
            System.out.println("等待连接");
            //轮询监听channel  如果有事件发生  将跳出监听  处理客户端事件
            //select()是阻塞方法   accpet()也是一个阻塞方法
            selector.select();
            //客户端的请求  会被监听到  并且把key放入到一个集合中  可以异步处理对应消息
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()) {
                SelectionKey selectionKey = iterator.next();
                iterator.remove();
                handleSelectionKey(selectionKey);
            }
        }

    }

    private static void handleSelectionKey(SelectionKey selectionKey) throws IOException {
        if (selectionKey.isAcceptable()) {
            //处理连接事件
            ServerSocketChannel socketChannel = (ServerSocketChannel) selectionKey.channel();
            //accept()是一个阻塞方法  但是因为此时处理的是连接事件  必定又客户端连接过来  所以此方法
            //马上就执行，继续处理其他事件
            SocketChannel channel = socketChannel.accept();
            channel.configureBlocking(false);
            //服务端接下来对read操作感兴趣
            channel.register(selectionKey.selector(), SelectionKey.OP_READ);
        } else if (selectionKey.isReadable()) {
            //处理read事件
            System.out.println("服务端收到数据");
            SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
            //创建读取缓冲区
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
            //read方法是一个阻塞方法  但read是响应事件，此时必定有客户端发送了消息 处理的是read事件  必定马上执行  不会阻塞线程
            int len = socketChannel.read(byteBuffer);
            if (len != -1) {
                System.out.println("服务端收到数据；" + new String(byteBuffer.array(), 0, len));
            }
            byteBuffer = ByteBuffer.wrap("hello".getBytes());
            socketChannel.write(byteBuffer);
            selectionKey.interestOps(SelectionKey.OP_READ | SelectionKey.OP_WRITE);
            socketChannel.close();
        }
    }
}

客户端代码实例

package com.socket.nio.client;

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

public class NIOClient {

    private Selector selector;

    public static void main(String[] args) throws Exception {
        NIOClient nioClient=new NIOClient();
        nioClient.initSocket("127.0.0.1",8888);
        nioClient.connect();
    }

    private void initSocket(String ip, int port) throws IOException {
        //创建一个socket通道  并且设置为非阻塞
        SocketChannel socketChannel = SocketChannel.open();
        socketChannel.configureBlocking(false);

        //创建一个selector
        this.selector = Selector.open();
        //连接服务端
        socketChannel.connect(new InetSocketAddress(ip,port));
        //注册当前的socketchannel到selector
        socketChannel.register(selector, SelectionKey.OP_CONNECT);
    }
int count =1;
    public void connect() throws  Exception{
        while(true){
            //对于客户端来说  一个客户端一个channel  此时select()是一个非阻塞方法
            //可以通过输出count，确定此时的select()是非阻塞的
            selector.select();
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            System.out.println(count++);
            while (iterator.hasNext()){
                SelectionKey selectionKey = iterator.next();
                iterator.remove();
                SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
                if (selectionKey.isConnectable()) {
                    if(socketChannel.isConnectionPending()){
                        socketChannel.finishConnect();
                    }
                    socketChannel.configureBlocking(false);
                    //发送消息给服务端
                    ByteBuffer byteBuffer = ByteBuffer.wrap("hello server".getBytes());
                    socketChannel.write(byteBuffer);
                    socketChannel.register(this.selector, SelectionKey.OP_READ);
                }else if(selectionKey.isReadable()){
                    ByteBuffer byteBuffer=ByteBuffer.allocate(1024);
                    int len = socketChannel.read(byteBuffer);
                    if(len!=-1){
                        System.out.println("收到服务端消息："+new String(byteBuffer.array(),0,len));
                    }
                }
               // socketChannel.close();
            }
        }
    }
}

劣势

因为selector多路复用器  会轮询所有的channel  如果有10000个channel  只有10个有动作  那么就会造成大量的轮询浪费  是不合理的

所以，在之后的处理中 NIO使用了epoll的方式  把轮询 变成响应（监听）