Netty——网络编程（阻塞理解及代码示例）

转x33g5p2x  于2022-08-17 转载在 其他  
字(8.1k)|赞(0)|评价(0)|浏览(467)

一、阻塞概述

  • 阻塞模式下，相关方法都会导致线程暂停。
    （1）、ServerSocketChannel.accept 会在没有连接建立时让线程暂停；
    （2）、SocketChannel.read 会在没有数据可读时让线程暂停；
    （3）、阻塞的表现其实就是线程暂停了，暂停期间不会占用 cpu，但线程相当于闲置；
  • 单线程下，阻塞方法之间相互影响，几乎不能正常工作，需要多线程支持。
  • 但多线程下，有新的问题，体现在以下方面
    （1）、32 位 jvm 一个线程 320k，64 位 jvm 一个线程 1024k，如果连接数过多，必然导致 OOM，并且线程太多，反而会因为频繁上下文切换导致性能降低；
    （2）、可以采用线程池技术来减少线程数和线程上下文切换，但治标不治本，如果有很多连接建立，但长时间 inactive，会阻塞线程池中所有线程，因此不适合长连接，只适合短连接；

二、阻塞模式服务端代码示例（使用nio实现）

  • 服务端代码
  1. package com.example.nettytest.nio.day3;
  3. import lombok.extern.slf4j.Slf4j;
  5. import java.io.IOException;
  6. import java.net.InetSocketAddress;
  7. import java.nio.ByteBuffer;
  8. import java.nio.channels.*;
  9. import java.util.ArrayList;
  10. import java.util.Iterator;
  12. import static com.example.nettytest.nio.day1.ByteBufferUtil.debugRead;
  13. /**
  14.  * @description: 阻塞模式服务端代码示例（使用nio实现）
  15.  * @author: xz
  16.  * @create: 2022-08-15 21:21
  17.  */
  18. @Slf4j
  19. public class TestServer {
  20.     public static void main(String[] args) throws IOException {
  21.         nioBlockServer();
  22.     }
  24.     /**
  25.      * 使用nio来理解阻塞模式(单线程服务端)
  26.      * */
  27.     private static void nioBlockServer() throws IOException {
  28.         //1、创建ByteBuffer，容量16
  29.         ByteBuffer byteBuffer = ByteBuffer.allocate(16);
  30.         //2、创建服务器
  31.         ServerSocketChannel ssc = ServerSocketChannel.open();
  32.         //3、绑定监听端口
  33.         ssc.bind(new InetSocketAddress(8080));
  34.         //4、连接集合
  35.         ArrayList<SocketChannel> channels = new ArrayList<>();
  36.         while(true){
  37.             log.info("connecting...");
  38.             //5、accept() 建立与客户端连接, SocketChannel 用来与客户端之间通信
  39.             SocketChannel sc = ssc.accept();//启动服务端，阻塞方法，线程停止运行
  40.             log.info("create connected SocketChannel... {}", sc);
  41.             //6、建立的客户端连接sc 添加到 连接集合channels中
  42.             channels.add(sc);
  43.             //7、遍历连接集合
  44.             for(SocketChannel channel : channels){
  45.                 log.info("before read channel ... {}", channel);
  46.                 // 8、 接收客户端发送的数据，从channel中读取数据写入到byteBuffer中
  47.                 channel.read(byteBuffer);// 启动客户端，阻塞方法，线程停止运行
  48.                 //切换读模式
  49.                 byteBuffer.flip();
  50.                 //打印可读取内容（从byteBuffer中读取数据内容）
  51.                 debugRead(byteBuffer);
  52.                 //切换回写模式
  53.                 byteBuffer.clear();
  54.                 log.info("after read channel ... {}", channel);
  55.             }
  56.         }
  57.     }
  58.     
  59. }

三、阻塞模式客户端代码示例（使用nio实现）

  • 客户端代码
  1. package com.example.nettytest.nio.day3;
  3. import java.io.IOException;
  4. import java.net.InetSocketAddress;
  5. import java.net.SocketAddress;
  6. import java.nio.channels.SocketChannel;
  7. /**
  8.  * @description:
  9.  * @author: xz
  10.  * @create: 2022-08-15 21:45
  11.  */
  12. public class TestClient {
  13.     public static void main(String[] args) throws IOException {
  14.         SocketChannel sc = SocketChannel.open();
  15.         sc.connect(new InetSocketAddress("localhost", 8080));
  16.         SocketAddress address = sc.getLocalAddress();
  17.         //debug模式后，点击src参数，右键选择 输入表达式sc.write(Charset.defaultCharset().encode("hello"));然后执行
  18.         System.out.println("waiting...");
  20.     }
  21. }

四、工具类代码示例

  • 工具类，打印输入、输出数据使用
  1. package com.example.nettytest.nio.day1;
  2.    
  3.    import io.netty.util.internal.StringUtil;
  4.    
  5.    import java.nio.ByteBuffer;
  6.    
  7.    import static io.netty.util.internal.MathUtil.isOutOfBounds;
  8.    import static io.netty.util.internal.StringUtil.NEWLINE;
  9.    
  10.    public class ByteBufferUtil {
  11.        private static final char[] BYTE2CHAR = new char[256];
  12.        private static final char[] HEXDUMP_TABLE = new char[256 * 4];
  13.        private static final String[] HEXPADDING = new String[16];
  14.        private static final String[] HEXDUMP_ROWPREFIXES = new String[65536 >>> 4];
  15.        private static final String[] BYTE2HEX = new String[256];
  16.        private static final String[] BYTEPADDING = new String[16];
  17.    
  18.        static {
  19.            final char[] DIGITS = "0123456789abcdef".toCharArray();
  20.            for (int i = 0; i < 256; i++) {
  21.                HEXDUMP_TABLE[i << 1] = DIGITS[i >>> 4 & 0x0F];
  22.                HEXDUMP_TABLE[(i << 1) + 1] = DIGITS[i & 0x0F];
  23.            }
  24.    
  25.            int i;
  26.    
  27.            // Generate the lookup table for hex dump paddings
  28.            for (i = 0; i < HEXPADDING.length; i++) {
  29.                int padding = HEXPADDING.length - i;
  30.                StringBuilder buf = new StringBuilder(padding * 3);
  31.                for (int j = 0; j < padding; j++) {
  32.                    buf.append("   ");
  33.                }
  34.                HEXPADDING[i] = buf.toString();
  35.            }
  36.    
  37.            // Generate the lookup table for the start-offset header in each row (up to 64KiB).
  38.            for (i = 0; i < HEXDUMP_ROWPREFIXES.length; i++) {
  39.                StringBuilder buf = new StringBuilder(12);
  40.                buf.append(NEWLINE);
  41.                buf.append(Long.toHexString(i << 4 & 0xFFFFFFFFL | 0x100000000L));
  42.                buf.setCharAt(buf.length() - 9, '|');
  43.                buf.append('|');
  44.                HEXDUMP_ROWPREFIXES[i] = buf.toString();
  45.            }
  46.    
  47.            // Generate the lookup table for byte-to-hex-dump conversion
  48.            for (i = 0; i < BYTE2HEX.length; i++) {
  49.                BYTE2HEX[i] = ' ' + StringUtil.byteToHexStringPadded(i);
  50.            }
  51.    
  52.            // Generate the lookup table for byte dump paddings
  53.            for (i = 0; i < BYTEPADDING.length; i++) {
  54.                int padding = BYTEPADDING.length - i;
  55.                StringBuilder buf = new StringBuilder(padding);
  56.                for (int j = 0; j < padding; j++) {
  57.                    buf.append(' ');
  58.                }
  59.                BYTEPADDING[i] = buf.toString();
  60.            }
  61.    
  62.            // Generate the lookup table for byte-to-char conversion
  63.            for (i = 0; i < BYTE2CHAR.length; i++) {
  64.                if (i <= 0x1f || i >= 0x7f) {
  65.                    BYTE2CHAR[i] = '.';
  66.                } else {
  67.                    BYTE2CHAR[i] = (char) i;
  68.                }
  69.            }
  70.        }
  71.    
  72.        /**
  73.         * 打印所有内容
  74.         * @param buffer
  75.         */
  76.        public static void debugAll(ByteBuffer buffer) {
  77.            int oldlimit = buffer.limit();
  78.            buffer.limit(buffer.capacity());
  79.            StringBuilder origin = new StringBuilder(256);
  80.            appendPrettyHexDump(origin, buffer, 0, buffer.capacity());
  81.            System.out.println("+--------+-------------------- all ------------------------+----------------+");
  82.            System.out.printf("position: [%d], limit: [%d]\n", buffer.position(), oldlimit);
  83.            System.out.println(origin);
  84.            buffer.limit(oldlimit);
  85.        }
  86.    
  87.        /**
  88.         * 打印可读取内容
  89.         * @param buffer
  90.         */
  91.        public static void debugRead(ByteBuffer buffer) {
  92.            StringBuilder builder = new StringBuilder(256);
  93.            appendPrettyHexDump(builder, buffer, buffer.position(), buffer.limit() - buffer.position());
  94.            System.out.println("+--------+-------------------- read -----------------------+----------------+");
  95.            System.out.printf("position: [%d], limit: [%d]\n", buffer.position(), buffer.limit());
  96.            System.out.println(builder);
  97.        }
  98.    
  99.        public static void main(String[] args) {
  100.            ByteBuffer buffer = ByteBuffer.allocate(10);
  101.            buffer.put(new byte[]{97, 98, 99, 100});
  102.            debugAll(buffer);
  103.        }
  104.    
  105.        private static void appendPrettyHexDump(StringBuilder dump, ByteBuffer buf, int offset, int length) {
  106.            if (isOutOfBounds(offset, length, buf.capacity())) {
  107.                throw new IndexOutOfBoundsException(
  108.                        "expected: " + "0 <= offset(" + offset + ") <= offset + length(" + length
  109.                                + ") <= " + "buf.capacity(" + buf.capacity() + ')');
  110.            }
  111.            if (length == 0) {
  112.                return;
  113.            }
  114.            dump.append(
  115.                    "         +-------------------------------------------------+" +
  116.                            NEWLINE + "         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |" +
  117.                            NEWLINE + "+--------+-------------------------------------------------+----------------+");
  118.    
  119.            final int startIndex = offset;
  120.            final int fullRows = length >>> 4;
  121.            final int remainder = length & 0xF;
  122.    
  123.            // Dump the rows which have 16 bytes.
  124.            for (int row = 0; row < fullRows; row++) {
  125.                int rowStartIndex = (row << 4) + startIndex;
  126.    
  127.                // Per-row prefix.
  128.                appendHexDumpRowPrefix(dump, row, rowStartIndex);
  129.    
  130.                // Hex dump
  131.                int rowEndIndex = rowStartIndex + 16;
  132.                for (int j = rowStartIndex; j < rowEndIndex; j++) {
  133.                    dump.append(BYTE2HEX[getUnsignedByte(buf, j)]);
  134.                }
  135.                dump.append(" |");
  136.    
  137.                // ASCII dump
  138.                for (int j = rowStartIndex; j < rowEndIndex; j++) {
  139.                    dump.append(BYTE2CHAR[getUnsignedByte(buf, j)]);
  140.                }
  141.                dump.append('|');
  142.            }
  143.    
  144.            // Dump the last row which has less than 16 bytes.
  145.            if (remainder != 0) {
  146.                int rowStartIndex = (fullRows << 4) + startIndex;
  147.                appendHexDumpRowPrefix(dump, fullRows, rowStartIndex);
  148.    
  149.                // Hex dump
  150.                int rowEndIndex = rowStartIndex + remainder;
  151.                for (int j = rowStartIndex; j < rowEndIndex; j++) {
  152.                    dump.append(BYTE2HEX[getUnsignedByte(buf, j)]);
  153.                }
  154.                dump.append(HEXPADDING[remainder]);
  155.                dump.append(" |");
  156.    
  157.                // Ascii dump
  158.                for (int j = rowStartIndex; j < rowEndIndex; j++) {
  159.                    dump.append(BYTE2CHAR[getUnsignedByte(buf, j)]);
  160.                }
  161.                dump.append(BYTEPADDING[remainder]);
  162.                dump.append('|');
  163.            }
  164.    
  165.            dump.append(NEWLINE +
  166.                    "+--------+-------------------------------------------------+----------------+");
  167.        }
  168.    
  169.        private static void appendHexDumpRowPrefix(StringBuilder dump, int row, int rowStartIndex) {
  170.            if (row < HEXDUMP_ROWPREFIXES.length) {
  171.                dump.append(HEXDUMP_ROWPREFIXES[row]);
  172.            } else {
  173.                dump.append(NEWLINE);
  174.                dump.append(Long.toHexString(rowStartIndex & 0xFFFFFFFFL | 0x100000000L));
  175.                dump.setCharAt(dump.length() - 9, '|');
  176.                dump.append('|');
  177.            }
  178.        }
  179.    
  180.        public static short getUnsignedByte(ByteBuffer buffer, int index) {
  181.            return (short) (buffer.get(index) & 0xFF);
  182.        }
  183.    }
  2. ### 五、阻塞模式代码示例本地调试
  4. * **启动服务端，服务端accept方法为阻塞方法，线程停止运行。如下图所示：**
  6. ![](//img.saoniuhuo.com/images/202208/21251660737711943.jpg)
  8. * **debug模式启动客户端，服务端read方法为，阻塞方法，线程停止运行。如下图所示：**
  9. ![](//img.saoniuhuo.com/images/202208/3731660737712597.jpg)
  11. * **客户端选择sc参数右键，点击【Evaluate Expression…】,弹出的窗口输入sc.write(Charset.defaultCharset().encode(“hello”)); 表示客户端发送数据。如下图所示：**
  13. ![](//img.saoniuhuo.com/images/202208/96851660737714144.jpg)
  15. ![](//img.saoniuhuo.com/images/202208/42931660737715511.jpg)
  17. * **此时，再看服务端，已经接收到了客户端发送的hello数据，服务端并重新进入到了accept方法，阻塞方法，线程停止运行。如下图所示：**
  19. ![](//img.saoniuhuo.com/images/202208/54421660737716977.jpg)
  21. * **最后放过客户端debug断点，输出如下图所示：**
  23. ![](//img.saoniuhuo.com/images/202208/56191660737718495.jpg)

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://wwwxz.blog.csdn.net/article/details/126355973

内容来源于网络，如有侵权，请联系作者删除！

netty

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com