• IO/NIO交互模拟及渐进式实现

    IO

    IO Server

    1. public class SocketServer {
    2.     public static void main(String[] args)  {
    3.         //server编号和client编号对应，优缺点注释在server端
    4.         //server1();
    5.         //server2();
    6.         server3();
    7.     }
    8.  
    9.     /**
    10.      * server1的缺点：
    11.      * 1、accept()方法阻塞了线程，要等客户端连接后才能继续处理（一个客户端连接，对应一个服务端处理线程）
    12.      * 2、当客户端与服务端完成一次交互后，程序就结束了
    13.      * 3、流关闭代码比较臃肿、BufferedWriter的内容需要在末尾加'\n'
    14.      * 4、交互的内容写死，不可以通过控制台输入
    15.      * 5、端口号固定、ip固定、readLine读取一行等等
    16.      */
    17.     public static void server1() {
    18.         ServerSocket serverSocket = null;
    19.         BufferedReader bufferedReader = null;
    20.         BufferedWriter bufferedWriter = null;
    21.         try {
    22.             serverSocket = new ServerSocket(8999);
    23.             //阻塞至客户端连接成功
    24.             Socket socket = serverSocket.accept();
    25.  
    26.             bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
    27.             //readLine会阻塞
    28.             String s = bufferedReader.readLine();
    29.             System.out.println("服务端接收到客户端的消息:" + s);
    30.  
    31.             bufferedWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
    32.             bufferedWriter.write("服务端发送消息给客户端\n");
    33.             bufferedWriter.flush();
    34.         } catch (IOException e) {
    35.             throw new RuntimeException(e);
    36.         } finally {
    37.             //各个try catch 必须分开写，聚合成一个会导致一个流关闭异常，无法进入其他流的关闭流程
    38.             if(serverSocket != null) {
    39.                 try {
    40.                     serverSocket.close();
    41.                 } catch (IOException e) {
    42.                     throw new RuntimeException(e);
    43.                 }
    44.             }
    45.  
    46.             if(bufferedWriter != null) {
    47.                 try {
    48.                     bufferedWriter.close();
    49.                 } catch (IOException e) {
    50.                     throw new RuntimeException(e);
    51.                 }
    52.             }
    53.             //只需要关闭外层的缓冲区，其close方法内部关闭了了传入的流
    54.             //如果不关闭，只是等待jvm兜底finally，会在不确定的时间内对资源造成占用(如果是文件读写会对文件描述符fd的占用)
    55.             if (bufferedReader != null) {
    56.                 try {
    57.                     bufferedReader.close();
    58.                 } catch (IOException e) {
    59.                     throw new RuntimeException(e);
    60.                 }
    61.             }
    62.         }
    63.     }
    64.  
    65.  
    66.     /**
    67.      * server2优点：
    68.      * 1、服务端和客户端可以任意次交互，可以连续发送消息
    69.      * 2、优化了流关闭的写法
    70.      *
    71.      * server2的缺点：
    72.      * 1、accept()方法阻塞了线程，要等客户端连接后才能继续处理（一个客户端连接，对应一个服务端处理线程）
    73.      * 2、cpu空转
    74.      * 3、ip固定等等
    75.      * 4、一个服务端只能和一个客户端交互
    76.      */
    77.     public static void server2() {
    78.         System.out.println("请输入端口号，并等待客户端连接...");
    79.         try (BufferedReader consoleReader = new BufferedReader(new InputStreamReader(System.in));
    80.              ServerSocket serverSocket = new ServerSocket(Integer.valueOf(consoleReader.readLine()));
    81.              Socket socket = serverSocket.accept();
    82.              BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
    83.              PrintWriter printWriter = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()));
    84.         ){
    85.             System.out.println("客户端已连接，开始和客户端交互...");
    86.             //这个循环保证可以连续发送或者接收多条消息
    87.             while (true) {
    88.                 if (bufferedReader.ready()) {
    89.                     System.out.println("收到客户端的消息:" + bufferedReader.readLine());
    90.                 }
    91.  
    92.                 if (consoleReader.ready()) {
    93.                     printWriter.println(consoleReader.readLine());
    94.                     printWriter.flush();
    95.                 }
    96.             }
    97.             //只能发一次接收一次
    98. //            while (true) {
    99. //                System.out.println("收到客户端的消息:" + bufferedReader.readLine());
    100. //
    101. //                printWriter.println(consoleReader.readLine());
    102. //                printWriter.flush();
    103. //            }
    104.  
    105.         } catch (IOException e) {
    106.             throw new RuntimeException(e);
    107.         }
    108.     }
    109.  
    110.     /**
    111.      * server3优点：
    112.      * 一个服务端可以和一个客户端交互
    113.      * 加上了线程池
    114.      *
    115.      * server3的缺点：
    116.      * 1、accept()方法阻塞了线程，要等客户端连接后才能继续处理（一个客户端连接，对应一个服务端处理线程）
    117.      * 2、cpu空转
    118.      * 3、ip固定等等
    119.      * 4、如果开启多个客户端，因System.in被服务端共享，所以服务端发送消息后，客户端会随机接收其中个别消息
    120.      */
    121.     public static void server3() {
    122.         ThreadPoolExecutor pool = new ThreadPoolExecutor(0, Runtime.getRuntime().availableProcessors() * 2,
    123.                 60L, TimeUnit.SECONDS,
    124.                 new SynchronousQueue());
    125.         System.out.println("请输入端口号，并等待客户端连接...");
    126.         try (BufferedReader consoleReader = new BufferedReader(new InputStreamReader(System.in));
    127.              ServerSocket serverSocket = new ServerSocket(Integer.valueOf(consoleReader.readLine()));
    128.         ){
    129.             //这个循环保证多个客户端连接
    130.             while (true) {
    131.                 Thread.sleep(1000);
    132.                 Socket socket = serverSocket.accept();
    133.                 System.out.println("客户端已连接，开始和客户端交互...");
    134.  
    135.                 pool.submit(new Thread(()->{
    136.                     try(
    137.                         BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
    138.                         PrintWriter printWriter = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()));
    139.                     ) {
    140.                         while (true) {
    141.                             Thread.sleep(1000);
    142.                             if(bufferedReader.ready()) {
    143.                                 System.out.println("收到客户端"+ Thread.currentThread() +"的消息:" + bufferedReader.readLine());
    144.                             }
    145.  
    146.                             if (consoleReader.ready()) {
    147.                                 printWriter.println(consoleReader.readLine());
    148.                                 printWriter.flush();
    149.                             }
    150.                         }
    151.                     } catch (IOException e) {
    152.                         throw new RuntimeException(e);
    153.                     } catch (InterruptedException e) {
    154.                         throw new RuntimeException(e);
    155.                     } finally {
    156.                         if(socket != null) {
    157.                             try {
    158.                                 socket.close();
    159.                             } catch (IOException e) {
    160.                                 throw new RuntimeException(e);
    161.                             }
    162.                         }
    163.                     }
    164.                 }));
    165.             }
    166.         } catch (IOException e) {
    167.             throw new RuntimeException(e);
    168.         } catch (InterruptedException e) {
    169.             throw new RuntimeException(e);
    170.         }
    171.     }
    172. }

    IO Client

    1. public class SocketClient {
    2.     public static void main(String[] args) {
    3.         //client1();
    4.         //client2();
    5.         client3();
    6.     }
    7.  
    8.     public static void client1() {
    9.         Socket socket = null;
    10.         BufferedReader bufferedReader = null;
    11.         BufferedWriter bufferedWriter = null;
    12.         try {
    13.             socket = new Socket("127.0.0.1", 8999);
    14.  
    15.             bufferedWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
    16.             //换行符必不可少，不然服务端readLine()无法判断一行已经写完
    17.             bufferedWriter.write("客户端发送消息给服务端\n");
    18.             bufferedWriter.flush();
    19.  
    20.             bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
    21.             String s = bufferedReader.readLine();
    22.             System.out.println("客户端接收到服务端的消息:" + s);
    23.  
    24.         } catch (IOException e) {
    25.             throw new RuntimeException(e);
    26.         } finally {
    27.             if(socket != null) {
    28.                 try {
    29.                     socket.close();
    30.                 } catch (IOException e) {
    31.                     throw new RuntimeException(e);
    32.                 }
    33.             }
    34.  
    35.             if(bufferedWriter != null) {
    36.                 try {
    37.                     bufferedWriter.close();
    38.                 } catch (IOException e) {
    39.                     throw new RuntimeException(e);
    40.                 }
    41.             }
    42.  
    43.             if (bufferedReader != null) {
    44.                 try {
    45.                     bufferedReader.close();
    46.                 } catch (IOException e) {
    47.                     throw new RuntimeException(e);
    48.                 }
    49.             }
    50.         }
    51.     }
    52.  
    53.  
    54.     public static void client2() {
    55.         System.out.println("请输入端口号:");
    56.         try (
    57.                 BufferedReader consoleReader = new BufferedReader(new InputStreamReader(System.in));
    58.                 Socket socket = new Socket("127.0.0.1", Integer.valueOf(consoleReader.readLine()));
    59.                 PrintWriter printWriter = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()));
    60.                 BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
    61.         ){
    62.             System.out.println("连接成功，开始和服务端交互");
    63.             //可以连续发送或者接收多条消息
    64.             while (true) {
    65.                 Thread.sleep(1000);
    66.                 if (bufferedReader.ready()) {
    67.                     System.out.println("收到服务端的消息:" + bufferedReader.readLine());
    68.                 }
    69.  
    70.                 if (consoleReader.ready()) {
    71.                     printWriter.println(consoleReader.readLine());
    72.                     printWriter.flush();
    73.                 }
    74.             }
    75.             //只能发一次接收一次
    76. //            while (true) {
    77. //                printWriter.println(consoleReader.readLine());
    78. //                printWriter.flush();
    79. //
    80. //                System.out.println("收到服务端的消息:" + bufferedReader.readLine());
    81. //            }
    82.  
    83.         } catch (IOException e) {
    84.             throw new RuntimeException(e);
    85.         } catch (InterruptedException e) {
    86.             throw new RuntimeException(e);
    87.         }
    88.     }
    89.  
    90.     public static void client3() {
    91.         System.out.println("请输入端口号:");
    92.         try (
    93.                 BufferedReader consoleReader = new BufferedReader(new InputStreamReader(System.in));
    94.                 Socket socket = new Socket("127.0.0.1", Integer.valueOf(consoleReader.readLine()));
    95.                 PrintWriter printWriter = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()));
    96.                 BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
    97.         ){
    98.             System.out.println("连接成功，开始和服务端交互");
    99.             //可以连续发送或者接收多条消息
    100.             while (true) {
    101.                 if (bufferedReader.ready()) {
    102.                     System.out.println("收到服务端的消息:" + bufferedReader.readLine());
    103.                 }
    104.  
    105.                 if (consoleReader.ready()) {
    106.                     printWriter.println(consoleReader.readLine());
    107.                     printWriter.flush();
    108.                 }
    109.             }
    110.         } catch (IOException e) {
    111.             throw new RuntimeException(e);
    112.         }
    113.     }
    114. }

    NIO

    NIO Server

    1. public class SocketServer {
    2.     public static void main(String[] args) {
    3.         //server1();
    4.         //server2();
    5.         //server3();
    6.         //server4();
    7.         server5();
    8.     }
    9.  
    10.  
    11.     /**
    12.      * 优点：NIO非阻塞方式，连接不会阻塞、读写不会阻塞
    13.      * 缺点：
    14.      * 1、当客户端与服务端完成一次交互后，程序就结束了
    15.      * 2、交互的内容写死，不可以通过控制台输入
    16.      * 3、cpu空转
    17.      * 4、未使用selector多路复用器，其编程其实还是类似与BIO形式（服务端还是每个线程对应一个客户端）
    18.      */
    19.     private static void server1() {
    20.  
    21.         try (
    22.             ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
    23.         ){
    24.             serverSocketChannel.socket().bind(new InetSocketAddress(9999));
    25.             serverSocketChannel.configureBlocking(false);
    26.             //accept设置了非阻塞，因此需要放置在循环中使用，否则程序直接结束了
    27.             while (true) {
    28.                 Thread.sleep(1000);
    29.                 SocketChannel socketChannel = serverSocketChannel.accept();
    30.                 if(socketChannel != null) {
    31.                     System.out.println("客户端已连接，开始和客户端交互...");
    32.                     socketChannel.configureBlocking(false);
    33.                     ByteBuffer readBuffer = ByteBuffer.allocate(1024);
    34.                     socketChannel.read(readBuffer);
    35.                     readBuffer.clear();
    36.  
    37.                     System.out.println("接收到客户端消息: " + new String(readBuffer.array(), "utf-8").trim());
    38.  
    39.                     ByteBuffer writeBuffer = ByteBuffer.wrap("发送消息给客户端".getBytes());
    40.                     socketChannel.write(writeBuffer);
    41.                 }
    42.             }
    43.         } catch (IOException e) {
    44.             throw new RuntimeException(e);
    45.         } catch (InterruptedException e) {
    46.             throw new RuntimeException(e);
    47.         }
    48.     }
    49.  
    50.  
    51.     /**
    52.      * 改良：
    53.      * 1、支持客户端和服务端一对一交互，多发
    54.      * 缺点：
    55.      * 1、不支持一个客户端对多个服务端
    56.      * 2、如果开启多个客户端，因System.in被服务端共享，所以服务端发送消息后，客户端会随机接收其中个别消息
    57.      * 3、cpu空转
    58.      * 4、未使用selector多路复用器，其编程其实还是类似与BIO形式（服务端还是每个线程对应一个客户端）
    59.      */
    60.     private static void server2() {
    61.         try (
    62.             ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
    63.             BufferedReader consoleReader = new BufferedReader(new InputStreamReader(System.in));
    64.         ){
    65.             serverSocketChannel.socket().bind(new InetSocketAddress(9999));
    66.             serverSocketChannel.configureBlocking(false);
    67.             //accept设置了非阻塞，因此需要放置在循环中使用，否则程序直接结束了
    68.             while (true) {
    69.                 Thread.sleep(1000);
    70.                 SocketChannel socketChannel = serverSocketChannel.accept();
    71.                 if(socketChannel != null) {
    72.                     System.out.println("客户端已连接，开始和客户端交互...");
    73.                     socketChannel.configureBlocking(false);
    74.                     ByteBuffer readBuffer = ByteBuffer.allocate(1024);
    75.                     while (true) {
    76.                         if(socketChannel.read(readBuffer) > 0) {
    77.                             System.out.println("接收到客户端消息: " + new String(readBuffer.array(), "utf-8").trim());
    78.                             readBuffer.clear();
    79.                         }
    80.  
    81.                         if (consoleReader.ready()) {
    82.                             ByteBuffer writeBuffer = ByteBuffer.wrap(consoleReader.readLine().getBytes());
    83.                             socketChannel.write(writeBuffer);
    84.                             writeBuffer.clear();
    85.                         }
    86.                         Thread.sleep(1000);
    87.                     }
    88.                 }
    89.             }
    90.         } catch (IOException e) {
    91.             throw new RuntimeException(e);
    92.         } catch (InterruptedException e) {
    93.             throw new RuntimeException(e);
    94.         }
    95.     }
    96.  
    97.     /**
    98.      * 改良：
    99.      * 1、支持一个客户端对多个服务端
    100.      * 缺点：
    101.      * 1、cpu空转
    102.      * 2、未使用selector多路复用器，其编程其实还是类似与BIO形式（服务端还是每个线程对应一个客户端）
    103.      */
    104.     private static void server3() {
    105.         try (
    106.             ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
    107.             BufferedReader consoleReader = new BufferedReader(new InputStreamReader(System.in));
    108.         ) {
    109.             serverSocketChannel.socket().bind(new InetSocketAddress(9999));
    110.             serverSocketChannel.configureBlocking(false);
    111.             List socketChannels = new ArrayList<>();
    112.             //accept设置了非阻塞，因此需要放置在循环中使用，否则程序直接结束了
    113.             while (true) {
    114.                 Thread.sleep(1000);
    115.                 boolean ready = consoleReader.ready();
    116.                 byte[] bytes = null;
    117.                 if (ready) {
    118.                     bytes = consoleReader.readLine().getBytes();
    119.                 }
    120.                 //调用一次accept再次使用会变成成null，除非有新的客户端连接
    121.                 SocketChannel socketChannel = serverSocketChannel.accept();
    122.                 if (socketChannel != null) {
    123.                     socketChannels.add(socketChannel);
    124.                     socketChannel.configureBlocking(false);
    125.                     System.out.println("客户端已连接，开始和客户端交互...");
    126.                 }
    127.                 for (SocketChannel channel : socketChannels) {
    128.                     ByteBuffer readBuffer = ByteBuffer.allocate(1024);
    129.                     if (channel.read(readBuffer) > 0) {
    130.                         System.out.println("接收到客户端消息: " + new String(readBuffer.array(), "utf-8").trim());
    131.                         readBuffer.clear();
    132.                     }
    133.  
    134.                     if (ready) {
    135.                         ByteBuffer writeBuffer = ByteBuffer.wrap(bytes);
    136.                         channel.write(writeBuffer);
    137.                         writeBuffer.clear();
    138.                     }
    139.                 }
    140.             }
    141.         } catch (IOException e) {
    142.             throw new RuntimeException(e);
    143.         } catch (InterruptedException e) {
    144.             throw new RuntimeException(e);
    145.         }
    146.     }
    147.  
    148.  
    149.     /**
    150.      * 改良：
    151.      * 1、支持一个客户端对多个服务端 (服务端发送消息，客户端都能收到，所有客户端发送消息服务端都能收到)
    152.      * 2、相对与server3多线程方式，服务端只需要启动一个主线程即可与所有客户端交互，
    153.      * 缺点：
    154.      * 1、cpu空转
    155.      * 2、未使用selector多路复用器，其编程其实还是类似与BIO形式（服务端还是每个线程对应一个客户端）
    156.      */
    157.     static final List socketChannels4 = new CopyOnWriteArrayList<>();
    158.     private static void server4() {
    159.         try (
    160.             ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
    161.             BufferedReader consoleReader = new BufferedReader(new InputStreamReader(System.in));
    162.         ) {
    163.             serverSocketChannel.socket().bind(new InetSocketAddress(9999));
    164.             serverSocketChannel.configureBlocking(false);
    165.             //accept设置了非阻塞，因此需要放置在循环中使用，否则程序直接结束了
    166.             while (true) {
    167.                 SocketChannel socketChannel = serverSocketChannel.accept();
    168.                 if (socketChannel != null) {
    169.                     System.out.println("客户端已连接，开始和客户端交互...");
    170.                     socketChannel.configureBlocking(false);
    171.                     socketChannels4.add(socketChannel);
    172.                 }
    173.                 Iterator iterator = socketChannels4.iterator();
    174.                 boolean ready = consoleReader.ready();
    175.                 byte[] writeBytes = null;
    176.                 if (ready) {
    177.                     writeBytes = consoleReader.readLine().getBytes();
    178.                 }
    179.  
    180.                 while (iterator.hasNext()) {
    181.                     ByteBuffer readBuffer = ByteBuffer.allocate(1024);
    182.                     SocketChannel channel = iterator.next();
    183.                     if (channel.read(readBuffer) > 0) {
    184.                         System.out.println("接收到客户端消息: " + new String(readBuffer.array(), "utf-8").trim());
    185.                         readBuffer.clear();
    186.                     }
    187.  
    188.                     if (ready) {
    189.                         ByteBuffer writeBuffer = ByteBuffer.wrap(writeBytes);
    190.                         channel.write(writeBuffer);
    191.                         writeBuffer.clear();
    192.                     }
    193.                 }
    194.                 Thread.sleep(1000);
    195.             }
    196.         } catch (IOException | InterruptedException e) {
    197.             throw new RuntimeException(e);
    198.         }
    199.     }
    200.  
    201.     /**
    202.      * 改良：
    203.      * 1、支持一个客户端对多个服务端 (服务端发送消息，客户端都能收到，所有客户端发送消息服务端都能收到)
    204.      * 2、相对与server3多线程方式，服务端只需要启动一个主线程即可与所有客户端交互，
    205.      * 缺点：
    206.      * 1、cpu空转
    207.      * 2、未使用selector多路复用器，其编程其实还是类似与BIO形式（服务端还是每个线程对应一个客户端）
    208.      */
    209.     private static void server5() {
    210.  
    211.         try (ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
    212.              Selector selector = Selector.open();
    213.              BufferedReader consoleReader = new BufferedReader(new InputStreamReader(System.in));
    214.         ) {
    215.             serverSocketChannel.socket().bind(new InetSocketAddress(9999));
    216.             serverSocketChannel.configureBlocking(false);
    217.             //将serverSocketChannel注册到selector, 并监听accept事件
    218.             serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
    219.             List socketChannels = new ArrayList<>();
    220.             while (true) {
    221.                 //非阻塞
    222.                 selector.select(1000);
    223.                 Iterator iterator = selector.selectedKeys().iterator();
    224.                 while (iterator.hasNext()) {
    225.                     SelectionKey selectionKey = iterator.next();
    226.                     if(selectionKey.isAcceptable()) {
    227.                         SocketChannel socketChannel = serverSocketChannel.accept();
    228.                         System.out.println("客户端已连接，开始和客户端交互...");
    229.                         socketChannel.configureBlocking(false);
    230.                         socketChannel.register(selector, SelectionKey.OP_READ);
    231.                         socketChannels.add(socketChannel);
    232.                     } else if(selectionKey.isReadable()) {
    233.                         SocketChannel socketChannel = (SocketChannel)selectionKey.channel();
    234.                         ByteBuffer readBuffer = ByteBuffer.allocate(1024);
    235.                         if (socketChannel.read(readBuffer) > 0) {
    236.                             System.out.println("接收到客户端消息: " + new String(readBuffer.array(), "utf-8").trim());
    237.                             readBuffer.clear();
    238.                         }
    239.                     }
    240.                     iterator.remove();
    241.                 }
    242.  
    243.                 if(consoleReader.ready()) {
    244.                     byte[] bytes = consoleReader.readLine().getBytes();
    245.                     for (SocketChannel socketChannel : socketChannels) {
    246.                         ByteBuffer writeBuffer = ByteBuffer.wrap(bytes);
    247.                         socketChannel.write(writeBuffer);
    248.                         writeBuffer.clear();
    249.                     }
    250.                 }
    251.             }
    252.         } catch (IOException e) {
    253.             throw new RuntimeException(e);
    254.         }
    255.     }
    256.  
    257. }

    NIO Client

    1. public class SocketClient {
    2.  
    3.     public static void main(String[] args) {
    4.         //client1();
    5.         //client2_3_4();
    6.         client5();
    7.     }
    8.  
    9.     private static void client1() {
    10.  
    11.         try (
    12.             SocketChannel socketChannel = SocketChannel.open();
    13.         ){
    14.             socketChannel.configureBlocking(false);
    15.             socketChannel.connect(new InetSocketAddress("127.0.0.1", 9999));
    16.             while (!socketChannel.finishConnect()) {
    17.                 Thread.sleep(1000);
    18.                 System.out.println("正在连接客户端...");
    19.             }
    20.  
    21.             ByteBuffer writeBuffer = ByteBuffer.wrap("向服务端发送消息".getBytes());
    22.             socketChannel.write(writeBuffer);
    23.             writeBuffer.clear();
    24.  
    25.             ByteBuffer readBuffer = ByteBuffer.allocate(1024);
    26.             while (true) {
    27.                 if(socketChannel.read(readBuffer) > 0) {
    28.                     System.out.println("接收到服务端消息: " + new String(readBuffer.array(), "utf-8").trim());
    29.                     readBuffer.clear();
    30.                     break;
    31.                 }
    32.                 Thread.sleep(1000);
    33.             }
    34.  
    35.         } catch (IOException | InterruptedException e) {
    36.             throw new RuntimeException(e);
    37.         }
    38.     }
    39.  
    40.  
    41.     private static void client2_3_4() {
    42.         try (
    43.             SocketChannel socketChannel = SocketChannel.open();
    44.             BufferedReader consoleReader = new BufferedReader(new InputStreamReader(System.in));
    45.         ){
    46.             socketChannel.configureBlocking(false);
    47.             socketChannel.connect(new InetSocketAddress("127.0.0.1", 9999));
    48.             while (!socketChannel.finishConnect()) {
    49.                 Thread.sleep(1000);
    50.                 System.out.println("正在连接客户端...");
    51.             }
    52.  
    53.             ByteBuffer readBuffer = ByteBuffer.allocate(1024);
    54.             while (true) {
    55.                 if(socketChannel.read(readBuffer) > 0) {
    56.                     System.out.println("接收到服务端消息: " + new String(readBuffer.array(), "utf-8").trim());
    57.                     readBuffer.clear();
    58.                 }
    59.  
    60.                 if (consoleReader.ready()) {
    61.                     ByteBuffer writeBuffer = ByteBuffer.wrap(consoleReader.readLine().getBytes());
    62.                     socketChannel.write(writeBuffer);
    63.                     writeBuffer.clear();
    64.                 }
    65.                 Thread.sleep(1000);
    66.             }
    67.         } catch (IOException | InterruptedException e) {
    68.             throw new RuntimeException(e);
    69.         }
    70.     }
    71.  
    72.     private static void client5() {
    73.         try (
    74.             SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9999));
    75.             Selector selector = Selector.open();
    76.             BufferedReader consoleReader = new BufferedReader(new InputStreamReader(System.in));
    77.         ){
    78.             socketChannel.configureBlocking(false);
    79.             socketChannel.register(selector, SelectionKey.OP_READ);
    80.             while (true) {
    81.                 selector.select(1000);
    82.                 Iterator iterator = selector.selectedKeys().iterator();
    83.                 while (iterator.hasNext()) {
    84.                     SelectionKey selectionKey = iterator.next();
    85.                     if (selectionKey.isReadable()) {
    86.                         SocketChannel channel = (SocketChannel) selectionKey.channel();
    87.                         ByteBuffer readBuffer = ByteBuffer.allocate(1024);
    88.                         if(channel.read(readBuffer) > 0) {
    89.                             System.out.println("接收到服务端消息: " + new String(readBuffer.array(), "utf-8").trim());
    90.                             readBuffer.clear();
    91.                         }
    92.                     }
    93.                     iterator.remove();
    94.                 }
    95.                 if (consoleReader.ready()){
    96.                     ByteBuffer writeBuffer = ByteBuffer.wrap(consoleReader.readLine().getBytes());
    97.                     socketChannel.write(writeBuffer);
    98.                     writeBuffer.clear();
    99.                 }
    100.             }
    101.         } catch (IOException e) {
    102.             throw new RuntimeException(e);
    103.         }
    104.     }
    105.  
    106. }

  • 相关阅读:
    Unity --- UI图像，锚点与轴心点
    神经网络（第二周）
    SpringBoot读取Yml中基本数据类型、List、Map、数组数据
    MUSIQ: Multi-scale Image Quality Transformer【图像质量评估】
    抽奖小游戏
    树形DP 复习笔记
    免费开源的100套Echarts大屏数据可视化模板分享
    观察者模式
    Python字典
    使用Vagrant创建和管理本地Kubernetes（K8s）集群的步骤是什么
  • 原文地址：https://blog.csdn.net/z275598733/article/details/133921600