Java 中 BIO、NIO和 AIO的深入浅析

/**
 * 
 * @author 闪电侠
 * @date 2018年10月14日
 * @Description:客户端
 */
public class IOClient {

 public static void main(String[] args) {
  // TODO 创建多个线程，模拟多个客户端连接服务端
  new Thread(() -> {
   try {
    Socket socket = new Socket("127.0.0.1", 3333);
    while (true) {
     try {
      socket.getOutputStream().write((new Date() + ": hello world").getBytes());
      Thread.sleep(2000);
     } catch (Exception e) {
     }
    }
   } catch (IOException e) {
   }
  }).start();

 }

}

/**
 * @author 闪电侠
 * @date 2018年10月14日
 * @Description: 服务端
 */
public class IOServer {

 public static void main(String[] args) throws IOException {
  // TODO 服务端处理客户端连接请求
  ServerSocket serverSocket = new ServerSocket(3333);

  // 接收到客户端连接请求之后为每个客户端创建一个新的线程进行链路处理
  new Thread(() -> {
   while (true) {
    try {
     // 阻塞方法获取新的连接
     Socket socket = serverSocket.accept();

     // 每一个新的连接都创建一个线程，负责读取数据
     new Thread(() -> {
      try {
       int len;
       byte[] data = new byte[1024];
       InputStream inputStream = socket.getInputStream();
       // 按字节流方式读取数据
       while ((len = inputStream.read(data)) != -1) {
        System.out.println(new String(data, 0, len));
       }
      } catch (IOException e) {
      }
     }).start();

    } catch (IOException e) {
    }

   }
  }).start();

 }

}

    // 1.根据操作系统选择适当的底层 io复用方法
    ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
    serverSocketChannel.bind(new InetSocketAddress(8082));
    //2.设置为非阻塞
    serverSocketChannel.configureBlocking(false);
    //3.选择与操作系统适配的选择器
    Selector selector = Selector.open();
    //将 serverSocket 的OP_ACCEPT 事件注册到 selector 选择器上
    serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
    while (true) {
      // 4.监听当前连接建立情况
      int select = selector.select();
      if (select > 0) {
        //判断连接业务类型
        Set<SelectionKey> set = selector.selectedKeys();
        Iterator<SelectionKey> iterator = set.iterator();
        while (iterator.hasNext()) {
          SelectionKey key = iterator.next();
          iterator.remove();
          //建立连接
          if (key.isAcceptable()) {
            ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
            //通过 accept 方法获取与 server端 已经创建好的 socket连接
            SocketChannel sc = ssc.accept();
            //设置为非阻塞
            sc.configureBlocking(false);
            //注册感兴趣的事件为 READ
            sc.register(selector, SelectionKey.OP_READ);
          }
          //可读
          else if (key.isReadable()) {
            SocketChannel socket = (SocketChannel) key.channel();
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
            socket.read(byteBuffer);
            System.out.println(new String(byteBuffer.array(), StandardCharsets.UTF_8));
            key.interestOps(SelectionKey.OP_WRITE);
          }
          //可写
          else if (key.isWritable()) {
            SocketChannel socket = (SocketChannel) key.channel();
            socket.write(ByteBuffer.wrap("I'm receive your message".getBytes(StandardCharsets.UTF_8)));
            socket.close();
            System.out.println("连接关闭成功！");
          }
        }
      }
    }

  private static void server() throws IOException {
    //根据操作系统建立对应的底层操作类
    AsynchronousServerSocketChannel channel = AsynchronousServerSocketChannel.open();
    channel.bind(new InetSocketAddress(8082));
    while (true) {
      Future<AsynchronousSocketChannel> future = channel.accept();
      try {
        AsynchronousSocketChannel asc = future.get();
        System.out.println("建立连接成功");
        Future<Integer> write = asc.write(ByteBuffer.wrap("Now let's exchange datas".getBytes(StandardCharsets.UTF_8)));
        while (!write.isDone()) {
          TimeUnit.SECONDS.sleep(2);
        }
        System.out.println("发送数据完成");
        asc.close();
      } catch (Exception e) {
        e.printStackTrace();
      }
    }
  }

  private static void client() throws Exception {
    AsynchronousSocketChannel socketChannel = AsynchronousSocketChannel.open();
    Future<Void> future = socketChannel.connect(new InetSocketAddress(8082));
    while (!future.isDone()) {
      TimeUnit.SECONDS.sleep(2);
    }
    ByteBuffer buffer = ByteBuffer.allocate(1024);
    Future<Integer> read = socketChannel.read(buffer);
    while (!read.isDone()) {
      TimeUnit.SECONDS.sleep(2);
    }
    System.out.println("接收服务器数据:" + new String(buffer.array(), 0, read.get()));
  }