愿你满腹经纶
愿你满腹经纶

【NIO与Netty】Netty优化与源码

黑马程序员Netty笔记合集
注意：由于章节连贯，此套笔记更适合学习《黑马Netty全套课程》的同学参考、复习使用。

文章名 链接
Java NIO入门：结合尚硅谷课程 文章地址
Netty 入门 文章地址
Netty进阶 文章地址 | 粘包、半包
Netty优化与源码 文章地址 | 源码分析

一、优化

1.1 扩展序列化算法

序列化，反序列化主要用在消息正文的转换上

  • 序列化时，需要将 Java 对象变为要传输的数据（可以是 byte[]，或 json 等，最终都需要变成 byte[]）
  • 反序列化时，需要将传入的正文数据还原成 Java 对象，便于处理

消息编解码器 MessageCodeSharable 原序列化和反序列化机制

// 反序列化
byte[] body = new byte[bodyLength];
byteByf.readBytes(body);
ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(body));
Message message = (Message) in.readObject();
message.setSequenceId(sequenceId);

// 序列化
ByteArrayOutputStream out = new ByteArrayOutputStream();
new ObjectOutputStream(out).writeObject(message);
byte[] bytes = out.toByteArray();

为了支持更多序列化算法，抽象一个 Serializer 接口

public interface Serializer {
    //反序列化
    <T> T deserializer(Class<T> clazz,byte[] bytes);

    //序列化
    <T> byte[] serializer(T object);

    enum SerializerAlgorithm implements Serializer{
        Java{
            @Override
            public <T> T deserializer(Class<T> clazz, byte[] bytes) {
                try {
                    ObjectInputStream ois=new ObjectInputStream(new ByteArrayInputStream(bytes));
                    return (T) ois.readObject();
                } catch (IOException | ClassNotFoundException e) {
                    throw new RuntimeException("反序列化失败！",e);
                }
            }

            @Override
            public <T> byte[] serializer(T object) {
                try {
                    ByteArrayOutputStream baos = new ByteArrayOutputStream();
                    ObjectOutputStream oos=new ObjectOutputStream(baos);
                    oos.writeObject(object);
                    return baos.toByteArray();
                } catch (IOException e) {
                    throw new RuntimeException("序列化失败！",e);
                }
            }
        },
        Json{
            @Override
            public <T> T deserializer(Class<T> clazz, byte[] bytes) {
                return new Gson().fromJson(new String(bytes, StandardCharsets.UTF_8),clazz);
            }

            @Override
            public <T> byte[] serializer(T object) {
                return new Gson().toJson(object).getBytes(StandardCharsets.UTF_8);
            }
        }
        // 需要从协议的字节中得到是哪种序列化算法
    	public static SerializerAlgorithm getByInt(int type) {
        	SerializerAlgorithm[] array = SerializerAlgorithm.values();
        	if (type < 0 || type > array.length - 1) {
            	throw new IllegalArgumentException("超过 SerializerAlgorithm 范围");
        	}
        	return array[type];
    	}
    }
}

增加配置类和配置文件

public abstract class Config {
    static Properties properties;
    static {
        try (InputStream in = Config.class.getResourceAsStream("/application.properties")) {
            properties = new Properties();
            properties.load(in);
        } catch (IOException e) {
            throw new ExceptionInInitializerError(e);
        }
    }
    public static int getServerPort() {
        String value = properties.getProperty("server.port");
        if(value == null) {
            return 8080;
        } else {
            return Integer.parseInt(value);
        }
    }
    //获取配置文件中配置的序列化算法
    public static Serializer.SerializerAlgorithm getSerializerAlgorithm() {
        String value = properties.getProperty("serializer.algorithm");
        if(value == null) {
            return Serializer.SerializerAlgorithm.Java;
        } else {
            return Serializer.SerializerAlgorithm.valueOf(value);
        }
    }
}

配置文件：application.properties

serializer.algorithm=Json

修改编解码器

/**
 * 必须和 LengthFieldBasedFrameDecoder 一起使用，确保接到的 ByteBuf 消息是完整的
 */
@Slf4j
@ChannelHandler.Sharable
public class MessageCodeSharable extends MessageToMessageCodec<ByteBuf, Message> {
    @Override
    protected void encode(ChannelHandlerContext ctx, Message msg, List<Object> list) throws Exception {
        ByteBuf byteBuf = ctx.alloc().buffer();
        //1.魔数：4个字节
        byteBuf.writeBytes(new byte[]{1,2,3,4});
        //2.版本号：1个字节
        byteBuf.writeByte(1);
        //3.序列化算法：1个字节，0 jdk ，1 json
        //获取配置文件中指定序的列化算法在序列化枚举数组中的索引下标
        byteBuf.writeByte(Config.getSerializerAlgorithm().ordinal());
        //4.消息类型：1个字节，由消息本身决定
        byteBuf.writeByte(msg.getMessageType());
        //5.请求序号：4个字节，由消息本身自带
        byteBuf.writeInt(msg.getSequenceId());
        byteBuf.writeByte(-1); //填充：无意义字节
        //使用指定的序列化算法转换正文内容
        byte[] bytes = Config.getSerializerAlgorithm().serializer(msg);
        //6.正文长度：4个字节
        byteBuf.writeInt(bytes.length);
        //7.消息正文：
        byteBuf.writeBytes(bytes);
        list.add(byteBuf);
    }

    @Override
    protected void decode(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf, List<Object> list) throws Exception {
        //1.魔数：4个字节
        int magicNum = byteBuf.readInt();
        //2.版本号：1个字节
        byte version=byteBuf.readByte();
        //3.序列化算法：0 jdk ，1 json
        byte serializerType=byteBuf.readByte();
        //4.指令类型：由消息本身决定
        byte messageType=byteBuf.readByte();
        //5.请求序号：由消息本身自带
        int sequenceId=byteBuf.readInt();
        byteBuf.readByte();
        //6.正文长度
        int length=byteBuf.readInt();
        //7.消息正文
        byte[] bytes=new byte[length];
        byteBuf.readBytes(bytes,0,length);
        //获取序列化算法
        Serializer.SerializerAlgorithm serializerAlgorithm = Config.getSerializerAlgorithm();
        //通过获取 Message 实现类对象
        Class<? extends Message> messageClass = Message.getMessageClass(messageType);
        //通过指定的算法将字节数组转换为 对应的Message实现类 对象
        Object message = Config.getSerializerAlgorithm().deserializer(messageClass, bytes);
        log.debug("{}, {}, {}, {}, {}, {}", magicNum, version, serializerType, messageType, sequenceId, length);
        log.debug("{}", message);
        list.add(message);
    }
}

消息实现类的获取

@Data
public abstract class Message implements Serializable {

    /**
     * 根据消息类型字节，获得对应的消息 class
     * @param messageType 消息类型字节
     * @return 消息 class
     */
    public static Class<? extends Message> getMessageClass(int messageType) {
        return messageClasses.get(messageType);
    }

    private int sequenceId;

    private int messageType;

    public abstract int getMessageType();

    public static final int LoginRequestMessage = 0;
    public static final int LoginResponseMessage = 1;
    public static final int ChatRequestMessage = 2;
    public static final int ChatResponseMessage = 3;
    public static final int GroupCreateRequestMessage = 4;
    public static final int GroupCreateResponseMessage = 5;
    public static final int GroupJoinRequestMessage = 6;
    public static final int GroupJoinResponseMessage = 7;
    public static final int GroupQuitRequestMessage = 8;
    public static final int GroupQuitResponseMessage = 9;
    public static final int GroupChatRequestMessage = 10;
    public static final int GroupChatResponseMessage = 11;
    public static final int GroupMembersRequestMessage = 12;
    public static final int GroupMembersResponseMessage = 13;
    public static final int PingMessage = 14;
    public static final int PongMessage = 15;
    /**
     * 请求类型 byte 值
     */
    public static final int RPC_MESSAGE_TYPE_REQUEST = 101;
    /**
     * 响应类型 byte 值
     */
    public static final int  RPC_MESSAGE_TYPE_RESPONSE = 102;

    private static final Map<Integer, Class<? extends Message>> messageClasses = new HashMap<>();

    static {
        messageClasses.put(LoginRequestMessage, LoginRequestMessage.class);
        messageClasses.put(LoginResponseMessage, LoginResponseMessage.class);
        messageClasses.put(ChatRequestMessage, ChatRequestMessage.class);
        messageClasses.put(ChatResponseMessage, ChatResponseMessage.class);
        messageClasses.put(GroupCreateRequestMessage, GroupCreateRequestMessage.class);
        messageClasses.put(GroupCreateResponseMessage, GroupCreateResponseMessage.class);
        messageClasses.put(GroupJoinRequestMessage, GroupJoinRequestMessage.class);
        messageClasses.put(GroupJoinResponseMessage, GroupJoinResponseMessage.class);
        messageClasses.put(GroupQuitRequestMessage, GroupQuitRequestMessage.class);
        messageClasses.put(GroupQuitResponseMessage, GroupQuitResponseMessage.class);
        messageClasses.put(GroupChatRequestMessage, GroupChatRequestMessage.class);
        messageClasses.put(GroupChatResponseMessage, GroupChatResponseMessage.class);
        messageClasses.put(GroupMembersRequestMessage, GroupMembersRequestMessage.class);
        messageClasses.put(GroupMembersResponseMessage, GroupMembersResponseMessage.class);
        messageClasses.put(RPC_MESSAGE_TYPE_REQUEST, RpcRequestMessage.class);
        messageClasses.put(RPC_MESSAGE_TYPE_RESPONSE, RpcResponseMessage.class);
    }

}

测试

/**
 * 出站
 */
@Test
public void test(){
    LoggingHandler LOGGING = new LoggingHandler();
    MessageCodeSharable CODEC = new MessageCodeSharable();
    EmbeddedChannel channel=new EmbeddedChannel(LOGGING,CODEC,LOGGING);
    channel.writeOutbound(new ChatRequestMessage("zhangsan","lisi","Hello"));
}

  • Java

    10:14:09 [DEBUG] [main] i.n.h.l.LoggingHandler : [id: 0xembedded, L:embedded - R:embedded] WRITE: ChatRequestMessage(super=Message(sequenceId=0, messageType=2), content=Hello, to=lisi, from=zhangsan)
10:14:09 [DEBUG] [main] i.n.h.l.LoggingHandler : [id: 0xembedded, L:embedded - R:embedded] WRITE: 259B
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 01 02 03 04 01 00 02 00 00 00 00 ff 00 00 00 f3 |................|
|00000010| ac ed 00 05 73 72 00 34 6f 72 67 2e 65 78 61 6d |....sr.4org.exam|
|00000020| 70 6c 65 2e 6a 61 76 61 2e 63 68 61 74 52 6f 6f |ple.java.chatRoo|
|00000030| 6d 2e 6d 65 73 73 61 67 65 2e 43 68 61 74 52 65 |m.message.ChatRe|
|00000040| 71 75 65 73 74 4d 65 73 73 61 67 65 78 13 15 e1 |questMessagex...|
|00000050| fe 0b 6d 55 02 00 03 4c 00 07 63 6f 6e 74 65 6e |..mU...L..conten|
|00000060| 74 74 00 12 4c 6a 61 76 61 2f 6c 61 6e 67 2f 53 |tt..Ljava/lang/S|
|00000070| 74 72 69 6e 67 3b 4c 00 04 66 72 6f 6d 71 00 7e |tring;L..fromq.~|
|00000080| 00 01 4c 00 02 74 6f 71 00 7e 00 01 78 72 00 29 |..L..toq.~..xr.)|
|00000090| 6f 72 67 2e 65 78 61 6d 70 6c 65 2e 6a 61 76 61 |org.example.java|
|000000a0| 2e 63 68 61 74 52 6f 6f 6d 2e 6d 65 73 73 61 67 |.chatRoom.messag|
|000000b0| 65 2e 4d 65 73 73 61 67 65 06 07 90 d6 50 f8 11 |e.Message....P..|
|000000c0| fa 02 00 02 49 00 0b 6d 65 73 73 61 67 65 54 79 |....I..messageTy|
|000000d0| 70 65 49 00 0a 73 65 71 75 65 6e 63 65 49 64 78 |peI..sequenceIdx|
|000000e0| 70 00 00 00 00 00 00 00 00 74 00 05 48 65 6c 6c |p........t..Hell|
|000000f0| 6f 74 00 08 7a 68 61 6e 67 73 61 6e 74 00 04 6c |ot..zhangsant..l|
|00000100| 69 73 69                                        |isi             |
+--------+-------------------------------------------------+----------------+

  • Json

    10:15:17 [DEBUG] [main] i.n.h.l.LoggingHandler : [id: 0xembedded, L:embedded - R:embedded] WRITE: ChatRequestMessage(super=Message(sequenceId=0, messageType=2), content=Hello, to=lisi, from=zhangsan)
10:15:18 [DEBUG] [main] i.n.h.l.LoggingHandler : [id: 0xembedded, L:embedded - R:embedded] WRITE: 96B
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 01 02 03 04 01 01 02 00 00 00 00 ff 00 00 00 50 |...............P|
|00000010| 7b 22 63 6f 6e 74 65 6e 74 22 3a 22 48 65 6c 6c |{"content":"Hell|
|00000020| 6f 22 2c 22 74 6f 22 3a 22 6c 69 73 69 22 2c 22 |o","to":"lisi","|
|00000030| 66 72 6f 6d 22 3a 22 7a 68 61 6e 67 73 61 6e 22 |from":"zhangsan"|
|00000040| 2c 22 73 65 71 75 65 6e 63 65 49 64 22 3a 30 2c |,"sequenceId":0,|
|00000050| 22 6d 65 73 73 61 67 65 54 79 70 65 22 3a 30 7d |"messageType":0}|
+--------+-------------------------------------------------+----------------+

1.2 参数调优

1）CONNECT_TIMEOUT_MILLIS

  • 属于 SocketChannal 参数

  • 用在客户端建立连接时，如果在指定毫秒内无法连接，会抛出 timeout 异常

  • SO_TIMEOUT 主要用在阻塞 IO，阻塞 IO 中 accept，read 等都是无限等待的，如果不希望永远阻塞，使用它调整超时时间

@Slf4j
public class TestConnectionTimeout {
    public static void main(String[] args) {
        NioEventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap()
                    .group(group)
                    .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 300)
                    .channel(NioSocketChannel.class)
                    .handler(new LoggingHandler());
            ChannelFuture future = bootstrap.connect("127.0.0.1", 8080);
            future.sync().channel().closeFuture().sync(); // 断点1
        } catch (Exception e) {
            e.printStackTrace();
             log.debug("timeout");
        } finally {
            group.shutdownGracefully();
        }
    }
}

超时异常

io.netty.channel.ConnectTimeoutException: connection timed out: localhost/127.0.0.1:8080
	at io.netty.channel.nio.AbstractNioChannel$AbstractNioUnsafe$1.run(AbstractNioChannel.java:263)
	at io.netty.util.concurrent.PromiseTask$RunnableAdapter.call(PromiseTask.java:38)
	at io.netty.util.concurrent.ScheduledFutureTask.run(ScheduledFutureTask.java:127)
	at io.netty.util.concurrent.AbstractEventExecutor.safeExecute(AbstractEventExecutor.java:163)
	at io.netty.util.concurrent.SingleThreadEventExecutor.runAllTasks(SingleThreadEventExecutor.java:416)
	at io.netty.channel.nio.NioEventLoop.run(NioEventLoop.java:515)
	at io.netty.util.concurrent.SingleThreadEventExecutor$5.run(SingleThreadEventExecutor.java:918)
	at io.netty.util.internal.ThreadExecutorMap$2.run(ThreadExecutorMap.java:74)
	at io.netty.util.concurrent.FastThreadLocalRunnable.run(FastThreadLocalRunnable.java:30)
	at java.lang.Thread.run(Thread.java:750)

另外源码部分 io.netty.channel.nio.AbstractNioChannel.AbstractNioUnsafe#connect

/**
 * 1.线程间使用 Promise 进行通信
 * 2.根据超时时间设置 定时抛异常任务 。如果定时任务未被取消，则说明连接超时
 */
@Override
public final void connect(
        final SocketAddress remoteAddress, final SocketAddress localAddress, final ChannelPromise promise) {
    // ...
    // Schedule connect timeout.
    int connectTimeoutMillis = config().getConnectTimeoutMillis();
    if (connectTimeoutMillis > 0) {
        connectTimeoutFuture = eventLoop().schedule(new Runnable() {
            @Override
            public void run() {                
                ChannelPromise connectPromise = AbstractNioChannel.this.connectPromise;
                ConnectTimeoutException cause =
                    new ConnectTimeoutException("connection timed out: " + remoteAddress); // 断点2
                if (connectPromise != null && connectPromise.tryFailure(cause)) {
                    close(voidPromise());
                }
            }
        }, connectTimeoutMillis, TimeUnit.MILLISECONDS);
    }
	// ...
}

2）SO_BACKLOG

  • 属于 ServerSocketChannal 参数
client server syns queue accept queue bind() listen() connect() 1. SYN SYN_SEND put SYN_RCVD 2. SYN + ACK ESTABLISHED 3. ACK put ESTABLISHED accept() client server syns queue accept queue
  1. 第一次握手，client 发送 SYN 到 server，状态修改为 SYN_SEND，server 收到，状态改变为 SYN_REVD，并将该请求放入 sync queue 队列
  2. 第二次握手，server 回复 SYN + ACK 给 client，client 收到，状态改变为 ESTABLISHED，并发送 ACK 给 server
  3. 第三次握手，server 收到 ACK，状态改变为 ESTABLISHED，将该请求从 sync queue 放入 accept queue

其中

  • 在 linux 2.2 之前，backlog 大小包括了两个队列的大小，在 2.2 之后，分别用下面两个参数来控制

  • sync queue - 半连接队列

    • 大小通过 /proc/sys/net/ipv4/tcp_max_syn_backlog 指定，在 syncookies 启用的情况下，逻辑上没有最大值限制，这个设置便被忽略

  • accept queue - 全连接队列

    • 其大小通过 /proc/sys/net/core/somaxconn 指定，在使用 listen 函数时，内核会根据传入的 backlog 参数与系统参数，取二者的较小值
    • 如果 accpet queue 队列满了，server 将发送一个拒绝连接的错误信息到 client

netty 中控制全连接

可以通过 option(ChannelOption.SO_BACKLOG, 值) 来设置大小

测试

  • 调试关键断点为：io.netty.channel.nio.NioEventLoop#processSelectedKey
/**
 * 服务器
 */
public static void main(String[] args) {
    NioEventLoopGroup group = new NioEventLoopGroup(2);
    try {
        Channel channel = new ServerBootstrap()
                .channel(NioServerSocketChannel.class)
                //设置全连接队列大小：2
                .option(ChannelOption.SO_BACKLOG,2)
                .group(group)
                .childHandler(new ChannelInitializer<NioSocketChannel>() {
                    @Override
                    protected void initChannel(NioSocketChannel channel) throws Exception {
                        channel.pipeline().addLast(new LoggingHandler());
                    }
                })
                .bind().sync().channel();
        channel.closeFuture().sync();
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        group.shutdownGracefully();
    }
}

/**
 * 客户端
 */
public static void main(String[] args) {
    NioEventLoopGroup group = new NioEventLoopGroup(2);
    try {
        Channel channel = new Bootstrap()
                .channel(NioSocketChannel.class)
                .group(group)
                .handler(new ChannelInitializer<NioSocketChannel>() {
                    @Override
                    protected void initChannel(NioSocketChannel channel) throws Exception {
                        channel.pipeline().addLast(new LoggingHandler());
                    }
                })
                .connect(new InetSocketAddress("127.0.0.1", 8080)).sync().channel();
        channel.closeFuture().sync();
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        group.shutdownGracefully();
    }
}

3）ulimit -n 数字

  • 属于操作系统参数
  • 属于临时调整，建议放在启动脚本里
  • 限制一个进程能够同时打开的文件描述符的数量

4）TCP_NODELAY

  • 属于 SocketChannal 参数
  • Nagle 算法设置，默认为 true

5）SO_SNDBUF & SO_RCVBUF

  • SO_SNDBUF 属于 SocketChannal 参数
  • SO_RCVBUF 既可用于 SocketChannal 参数，也可以用于 ServerSocketChannal 参数（建议设置到 ServerSocketChannal 上）
  • 现在的操作系统比较智能，会自动调整。不建议设置

6）ALLOCATOR

  • 属于 SocketChannal 参数。ByteBuf 分配器
  • 用来分配 ByteBuf， ctx.alloc()

7）RCVBUF_ALLOCATOR

  • 属于 SocketChannal 参数
  • 控制 netty 接收缓冲区大小
  • 负责入站数据的分配，决定入站缓冲区的大小（并可动态调整），统一采用 direct 直接内存，具体池化还是非池化由 allocator 决定

1.3 RPC 框架

1）准备工作

这些代码可以认为是现成的，无需从头编写练习

为了简化起见，在原来聊天项目的基础上新增 Rpc 请求和响应消息

增加 Rpc 消息类型：Message 接口中增加

@Data
public abstract class Message implements Serializable {

    // 省略旧的代码

    public static final int RPC_MESSAGE_TYPE_REQUEST = 101;
    public static final int  RPC_MESSAGE_TYPE_RESPONSE = 102;

    static {
        // ...
        messageClasses.put(RPC_MESSAGE_TYPE_REQUEST, RpcRequestMessage.class);
        messageClasses.put(RPC_MESSAGE_TYPE_RESPONSE, RpcResponseMessage.class);
    }

}

Rpc请求消息：RpcRequestMessage

@Getter
@ToString(callSuper = true)
public class RpcRequestMessage extends Message {

    /**
     * 调用的接口全限定名，服务端根据它找到实现
     */
    private String interfaceName;
    /**
     * 调用接口中的方法名
     */
    private String methodName;
    /**
     * 方法返回类型
     */
    private Class<?> returnType;
    /**
     * 方法参数类型数组
     */
    private Class[] parameterTypes;
    /**
     * 方法参数值数组
     */
    private Object[] parameterValue;

    public RpcRequestMessage(int sequenceId, String interfaceName, String methodName, Class<?> returnType, Class[] parameterTypes, Object[] parameterValue) {
        super.setSequenceId(sequenceId);
        this.interfaceName = interfaceName;
        this.methodName = methodName;
        this.returnType = returnType;
        this.parameterTypes = parameterTypes;
        this.parameterValue = parameterValue;
    }

    @Override
    public int getMessageType() {
        return RPC_MESSAGE_TYPE_REQUEST;
    }
}

Rpc响应消息：RpcResponseMessage

@Data
@ToString(callSuper = true)
public class RpcResponseMessage extends Message {
    /**
     * 返回值
     */
    private Object returnValue;
    /**
     * 异常值
     */
    private Exception exceptionValue;

    @Override
    public int getMessageType() {
        return RPC_MESSAGE_TYPE_RESPONSE;
    }
}

服务器架子

@Slf4j
public class RpcServer {
    public static void main(String[] args) {
        NioEventLoopGroup Boss=new NioEventLoopGroup(1);
        NioEventLoopGroup Worker=new NioEventLoopGroup(2);
        LoggingHandler LOGGING_HANDLER=new LoggingHandler();
        MessageCodeSharable MESSAGE_CODEC=new MessageCodeSharable();
        
        //1.RPC消息发送处理器
        RpcRequestMessageHandler RPC_REQUEST_HANDLER=new RpcRequestMessageHandler();
        try {
            ServerBootstrap serverBootstrap=new ServerBootstrap();
            serverBootstrap.channel(NioServerSocketChannel.class);
            serverBootstrap.group(Boss,Worker);
            serverBootstrap.childHandler(new ChannelInitializer<NioSocketChannel>() {
                @Override
                protected void initChannel(NioSocketChannel ch) throws Exception {
                    ch.pipeline().addLast(new ProcotolFrameDecoder()); //处理粘包半包
                    ch.pipeline().addLast(LOGGING_HANDLER); //记录日志
                    ch.pipeline().addLast(MESSAGE_CODEC); //消息协议 编码、解码

                    //1.RPC消息发送处理器
                    ch.pipeline().addLast(RPC_REQUEST_HANDLER);
                }
            });
            Channel channel = serverBootstrap.bind(8080).sync().channel();
            channel.closeFuture().sync();
        } catch (InterruptedException e) {
            log.debug("Server error,{}",e);
        } finally {
            Boss.shutdownGracefully();
            Worker.shutdownGracefully();
        }
    }
}

客户端架子

@Slf4j
public class RpcClient {
    public static void main(String[] args) {
        NioEventLoopGroup group=new NioEventLoopGroup(2);
        LoggingHandler LOGGING_HANDLER=new LoggingHandler();
        MessageCodeSharable MESSAGE_CODEC=new MessageCodeSharable();

        //1.RPC消息响应处理器
        RpcResponseMessageHandler RPC_RESPONSE_HANDLER=new RpcResponseMessageHandler();
        try {
            Bootstrap bootstrap=new Bootstrap();
            bootstrap.channel(NioSocketChannel.class);
            bootstrap.group(group);
            bootstrap.handler(new ChannelInitializer<NioSocketChannel>() {
                @Override
                protected void initChannel(NioSocketChannel ch) throws Exception {
                    ch.pipeline().addLast(new ProcotolFrameDecoder()); //处理粘包半包
                    ch.pipeline().addLast(LOGGING_HANDLER); //记录日志
                    ch.pipeline().addLast(MESSAGE_CODEC); //消息协议 编码、解码

                    //1.RPC消息响应处理器
                    ch.pipeline().addLast(RPC_RESPONSE_HANDLER);
                }
            });
            Channel channel = bootstrap.connect(new InetSocketAddress("127.0.0.1", 8080)).sync().channel();
            channel.closeFuture().sync();
        } catch (InterruptedException e) {
            log.debug("Client error,{}",e);
        } finally {
            group.shutdownGracefully();
        }
    }
}

相关服务

  • HelloService

    public interface HelloService {
    String sayHello(String msg);
}

  • HelloServiceImpl

    //有所修改
public class HelloServiceImpl implements HelloService{
    @Override
    public String sayHello(String msg) {
        System.out.println("你好!"+msg);
        return "你好!"+msg;
    }
}

  • ServiceFactory：通过 Class对象 获取 该类的实例对象

    public abstract class ServiceFactory {
    static Properties properties;
    static Map<Class<?>,Object> map =new ConcurrentHashMap<>();

    static{
        try (InputStream in = Config.class.getResourceAsStream("/application.properties")){
            properties =new Properties();
            properties.load(in);
            Set<String> names =properties.stringPropertyNames();
            for (String name :names) {
                if (name.endsWith("Service")) {
                    Class<?> interfaceclass =Class.forName(name);
                    Class<?> instanceclass =Class.forName(properties.getProperty(name));
                    map.put(interfaceclass, instanceclass.newInstance());
                }
            }
        }catch (IOException | ClassNotFoundException | InstantiationException | IllegalAccessException e){
            throw new ExceptionInInitializerError(e);
        }
    }

    public static <T> T getService(Class<T> interfaceClass){
        return (T)map.get(interfaceClass);
    }

}

  • application.properties

    serializer.algorithm=Json
org.example.java.chatRoom.server.service.HelloService=org.example.java.chatRoom.server.service.HelloServiceImpl

2）客户端发送 rpc请求

@Slf4j
public class RpcClient {
    public static void main(String[] args) {
        NioEventLoopGroup group=new NioEventLoopGroup(2);
        LoggingHandler LOGGING_HANDLER=new LoggingHandler();
        MessageCodeSharable MESSAGE_CODEC=new MessageCodeSharable();

        //2.RPC消息响应处理器
        RpcResponseMessageHandler RPC_RESPONSE_HANDLER=new RpcResponseMessageHandler();
        try {
            Bootstrap bootstrap=new Bootstrap();
            bootstrap.channel(NioSocketChannel.class);
            bootstrap.group(group);
            bootstrap.handler(new ChannelInitializer<NioSocketChannel>() {
                @Override
                protected void initChannel(NioSocketChannel ch) throws Exception {
                    ch.pipeline().addLast(new ProcotolFrameDecoder()); //处理粘包半包
                    ch.pipeline().addLast(LOGGING_HANDLER); //记录日志
                    ch.pipeline().addLast(MESSAGE_CODEC); //消息协议 编码、解码

                    //2.RPC消息响应处理器
                    ch.pipeline().addLast(RPC_RESPONSE_HANDLER);
                }
            });
            Channel channel = bootstrap.connect(new InetSocketAddress("127.0.0.1", 8080)).sync().channel();
            //1.连接完成后发送 Rpc请求消息
            ChannelFuture channelFuture = channel.writeAndFlush(new RpcRequestMessage(
                    0,
                    "org.example.java.chatRoom.server.service.HelloService",
                    "sayHello",
                    String.class,
                    new Class[]{String.class},
                    new Object[]{"张三"}));
            channelFuture.addListener(promise->{
                if(!promise.isSuccess()){
                    Throwable cause=promise.cause();
                    log.debug("error,{}",cause);
                }
            });
            channel.closeFuture().sync();
        } catch (InterruptedException e) {
            log.debug("Client error,{}",e);
        } finally {
            group.shutdownGracefully();
        }
    }
}

3）服务器接收并响应

@Slf4j
@ChannelHandler.Sharable
public class RpcRequestMessageHandler extends SimpleChannelInboundHandler<RpcRequestMessage> {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, RpcRequestMessage message) throws Exception {
        RpcResponseMessage response = new RpcResponseMessage();
        response.setSequenceId(message.getSequenceId());
        try {
            //1.获取实现对象
            String interfaceName = message.getInterfaceName();
            HelloService service = (HelloService) ServiceFactory.getService(Class.forName(interfaceName));
            //2.调用方法
            String methodName = message.getMethodName();
            Class[] parameterTypes = message.getParameterTypes();
            Object[] parameterValue = message.getParameterValue();
            Method method = service.getClass().getMethod(methodName, parameterTypes);
            Object result = method.invoke(service, parameterValue);
            //3.设置返回值
            response.setReturnValue(result);
        } catch (ClassNotFoundException e) {
            log.debug("RpcRequestHandler erro,{}",e);
            response.setExceptionValue(e);
        } finally {
        }
        ctx.writeAndFlush(response);
    }
}

4）客户端简单处理响应

@Slf4j
@ChannelHandler.Sharable
public class RpcResponseMessageHandler extends SimpleChannelInboundHandler<RpcResponseMessage> {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, RpcResponseMessage message) throws Exception {
        log.debug("{}", message);
    }
}

【NIO与Netty】Netty优化与源码_第1张图片

5）客户端2.0：管理Channel

包括 channel 管理，代理，接收结果

@Slf4j
public class RpcClientManager {
    public static void main(String[] args) {
        HelloService service=getProxyService(HelloService.class);
        //方法调用暂时没有考虑返回值
        service.sayHello("小红");
    }

    //创建代理类对象：代理调用服务端的方法
    public static <T> T getProxyService(Class<T> serviceClass){
        //类加载器
        ClassLoader classLoader = serviceClass.getClassLoader();
        //代理类的接口数组
        Class<?>[] classes = {serviceClass};
        //方法处理器
        Object o= Proxy.newProxyInstance(classLoader,classes,(proxy, method, args)->{
            //1.生成 rpc消息对象
            int serquenceId= SequenceIdGenerator.nextId();
            RpcRequestMessage message = new RpcRequestMessage(
                    serquenceId,
                    serviceClass.getName(),
                    method.getName(),
                    method.getReturnType(),
                    method.getParameterTypes(),
                    args);
            //2.发送消息
            getChannel().writeAndFlush(message);
            //3.暂时返回null
            return null;
        });
        return (T) o;
    }


    private static Channel channel=null;
    //获取单例channel
    public static Channel getChannel(){
        if(channel!=null) return channel;
        synchronized (RpcClientManager.class){
            if (channel!=null) return channel;
            initChannel();
            return channel;
        }
    }
    //初始化Channel
    private static void initChannel() {
        NioEventLoopGroup group=new NioEventLoopGroup(2);
        LoggingHandler LOGGING_HANDLER=new LoggingHandler();
        MessageCodeSharable MESSAGE_CODEC=new MessageCodeSharable();

        //RPC消息响应处理器
        RpcResponseMessageHandler RPC_RESPONSE_HANDLER=new RpcResponseMessageHandler();
        Bootstrap bootstrap=new Bootstrap();
        bootstrap.channel(NioSocketChannel.class);
        bootstrap.group(group);
        bootstrap.handler(new ChannelInitializer<NioSocketChannel>() {
            @Override
            protected void initChannel(NioSocketChannel ch) throws Exception {
                ch.pipeline().addLast(new ProcotolFrameDecoder()); //处理粘包半包
                ch.pipeline().addLast(LOGGING_HANDLER); //记录日志
                ch.pipeline().addLast(MESSAGE_CODEC); //消息协议 编码、解码

                //RPC消息响应处理器
                ch.pipeline().addLast(RPC_RESPONSE_HANDLER);
            }
        });
        try {
            channel = bootstrap.connect(new InetSocketAddress("127.0.0.1", 8080)).sync().channel();
            channel.closeFuture().addListener(future -> {
                group.shutdownGracefully();
            });
        } catch (InterruptedException e) {
            log.debug("Client error,{}",e);
            group.shutdownGracefully();
        }
    }
}

  • SequenceIdGenerator

    public class SequenceIdGenerator {
    private static final AtomicInteger id=new AtomicInteger();
    public static int nextId(){
        return id.incrementAndGet();
    }
}

6）客户端3.0：等待响应

发送 rpc请求 的线程等待响应结果

@Slf4j
public class RpcClientManager {
    public static void main(String[] args) {
        HelloService service=getProxyService(HelloService.class);
        System.out.println(service.sayHello("小红"));
        System.out.println(service.sayHello("小明"));
        System.out.println(service.sayHello("小紫"));
    }

    //创建代理类对象
    public static <T> T getProxyService(Class<T> serviceClass){
        //类加载器
        ClassLoader classLoader = serviceClass.getClassLoader();
        //代理类的接口数组
        Class<?>[] classes = {serviceClass};
        //方法处理器
        Object o= Proxy.newProxyInstance(classLoader,classes,(proxy, method, args)->{
            //1.生成 rpc消息对象
            int serquenceId= SequenceIdGenerator.nextId();
            RpcRequestMessage message = new RpcRequestMessage(
                    serquenceId,
                    serviceClass.getName(),
                    method.getName(),
                    method.getReturnType(),
                    method.getParameterTypes(),
                    args);
            //2.发送消息
            getChannel().writeAndFlush(message);
            //3.创建 promise容器 接收返回消息：并指定 promise对象 异步接收结果线程
            DefaultPromise<Object> promise=new DefaultPromise<>(getChannel().eventLoop());
            RpcResponseMessageHandler.PROMISES.put(serquenceId,promise);
            //4.等待结果返回
            promise.await();
            //5.返回结果
            if (promise.isSuccess()) {
                return promise.getNow();
            }else {
                throw new RuntimeException(promise.cause());
            }
        });
        return (T) o;
    }


    private static Channel channel=null;

    public static Channel getChannel(){
        if(channel!=null) return channel;
        synchronized (RpcClientManager.class){
            if (channel!=null) return channel;
            initChannel();
            return channel;
        }
    }

    private static void initChannel() {
        NioEventLoopGroup group=new NioEventLoopGroup(2);
        LoggingHandler LOGGING_HANDLER=new LoggingHandler();
        MessageCodeSharable MESSAGE_CODEC=new MessageCodeSharable();

        //RPC消息响应处理器
        RpcResponseMessageHandler RPC_RESPONSE_HANDLER=new RpcResponseMessageHandler();
        Bootstrap bootstrap=new Bootstrap();
        bootstrap.channel(NioSocketChannel.class);
        bootstrap.group(group);
        bootstrap.handler(new ChannelInitializer<NioSocketChannel>() {
            @Override
            protected void initChannel(NioSocketChannel ch) throws Exception {
                ch.pipeline().addLast(new ProcotolFrameDecoder()); //处理粘包半包
                ch.pipeline().addLast(LOGGING_HANDLER); //记录日志
                ch.pipeline().addLast(MESSAGE_CODEC); //消息协议 编码、解码

                //RPC消息响应处理器
                ch.pipeline().addLast(RPC_RESPONSE_HANDLER);
            }
        });
        try {
            channel = bootstrap.connect(new InetSocketAddress("127.0.0.1", 8080)).sync().channel();
            channel.closeFuture().addListener(future -> {
                group.shutdownGracefully();
            });
        } catch (InterruptedException e) {
            log.debug("Client error,{}",e);
            group.shutdownGracefully();
        }
    }
}

处理响应线程设置返回结果

@Slf4j
@ChannelHandler.Sharable
public class RpcResponseMessageHandler extends SimpleChannelInboundHandler<RpcResponseMessage> {
    //响应后将返回结果与对应的请求进行设置
    public static final Map<Integer, Promise<Object>> PROMISES=new ConcurrentHashMap<>();

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, RpcResponseMessage message) throws Exception {
        //将响应结果返回给调用者
        Promise<Object> promise = PROMISES.remove(message.getSequenceId());
        Object returnValue = message.getReturnValue();
        Exception exceptionValue = message.getExceptionValue();
        if(exceptionValue!=null){
            promise.setFailure(exceptionValue);
        }else{
            promise.setSuccess(returnValue);
        }
    }
}

7）几个问题

  • RpcResponseMessageHandler 中 PROMISES集合中的泛型问题：Promise，不能为 Promise

    • Promise 只能用来接收值，不能设置值。除非设置 null

  • RpcResponseMessageHandler 中将响应结果设置到 promise 的同时，需要从集合中移除

  • RpcResponseMessageHandler 是否可以共享？

    • 可以。因为共享变量为 ConcurrentHashMap，不存在线程安全问题。

  • 远程方法调用出错解决：比如 sayHello出现除0异常

    1. 客户断收到的响应数据太长：LengthFieldBasedFrameDecoder 抛出 TooLongFrameException

    2. 将响应信息中异常的信息缩短

      try {
    ......
    response.setReturnValue(result);
} catch (Exception e) {
    log.debug("RpcRequestHandler erro,{}",e);
    //缩短异常的信息
    String msg = e.getCause().getMessage();
    response.setExceptionValue(new Exception("远程调用出错："+msg));
} finally {
    ctx.writeAndFlush(response);
}

    • 二、源码分析

    2.1 启动剖析

    Nio流程总览

    //1 netty 中使用 NioEventLoopGroup （简称 nio boss 线程）来封装线程和 selector
Selector selector = Selector.open(); 

//2 创建 NioServerSocketChannel，同时会初始化它关联的 handler，以及为原生 ssc 存储 config
NioServerSocketChannel attachment = new NioServerSocketChannel();

//3 创建 NioServerSocketChannel 时，创建了 java 原生的 ServerSocketChannel
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open(); 
serverSocketChannel.configureBlocking(false);

//4 启动 nio boss 线程执行接下来的操作

//5 注册（仅关联 selector 和 NioServerSocketChannel），未关注事件
SelectionKey selectionKey = serverSocketChannel.register(selector, 0, attachment);

//6 head -> 初始化器 -> ServerBootstrapAcceptor -> tail，初始化器是一次性的，只为添加 acceptor

//7 绑定端口
serverSocketChannel.bind(new InetSocketAddress(8080));

//8 触发 channel active 事件，在 head 中关注 op_accept 事件
selectionKey.interestOps(SelectionKey.OP_ACCEPT);

    启动跟源码

    服务器入口 io.netty.bootstrap.ServerBootstrap#bind

    关键代码 io.netty.bootstrap.AbstractBootstrap#doBind

    private ChannelFuture doBind(final SocketAddress localAddress) {
	//1.执行 初始化
    //2.异步执行 注册
    final ChannelFuture regFuture = initAndRegister();
    final Channel channel = regFuture.channel();
    if (regFuture.cause() != null) {
        return regFuture;
    }
    
    //已经完成：
    if (regFuture.isDone()) {
        ChannelPromise promise = channel.newPromise();
        //3.立刻调用 doBind0
        doBind0(regFuture, channel, localAddress, promise);
        return promise;
    } 
    //没有完成：添加回调函数
    else {
        final PendingRegistrationPromise promise = new PendingRegistrationPromise(channel);
        regFuture.addListener(new ChannelFutureListener() {
            @Override
            public void operationComplete(ChannelFuture future) throws Exception {
                Throwable cause = future.cause();
                if (cause != null) {
                    promise.setFailure(cause);//处理异常...
                } else {
                    promise.registered();
					//3.由注册线程去执行 doBind0：绑定端口号、触发 active 事件、注册accept事件
                    doBind0(regFuture, channel, localAddress, promise);
                }
            }
        });
        return promise;
    }
}

    关键代码 io.netty.bootstrap.AbstractBootstrap#initAndRegister

    //1.执行 初始化
//2.异步执行 注册
final ChannelFuture initAndRegister() {
    Channel channel = null;
    try {
        //1 初始化
        //1.1 创建 NioServerSocketChannel
        channel = channelFactory.newChannel();
        //1.2 给 NioServerSocketChannel 添加一个初始化器 ChannelInitializer
        init(channel);
    } catch (Throwable t) { // 处理异常...
        return new DefaultChannelPromise(new FailedChannel(), GlobalEventExecutor.INSTANCE).setFailure(t);
    }

    //2 注册：将原生 channel 注册到 selector 上
    ChannelFuture regFuture = config().group().register(channel);
    if (regFuture.cause() != null) { // 处理异常...
    }
    return regFuture;
}

    关键代码 io.netty.bootstrap.ServerBootstrap#init

    //1.2 给 NioServerSocketChannel 添加一个初始化器 ChannelInitializer
void init(Channel channel) throws Exception {
    final Map<ChannelOption<?>, Object> options = options0();
    synchronized (options) {
        setChannelOptions(channel, options, logger);
    }

    final Map<AttributeKey<?>, Object> attrs = attrs0();
    synchronized (attrs) {
        for (Entry<AttributeKey<?>, Object> e: attrs.entrySet()) {
            @SuppressWarnings("unchecked")
            AttributeKey<Object> key = (AttributeKey<Object>) e.getKey();
            channel.attr(key).set(e.getValue());
        }
    }

    ChannelPipeline p = channel.pipeline();

    final EventLoopGroup currentChildGroup = childGroup;
    final ChannelHandler currentChildHandler = childHandler;
    final Entry<ChannelOption<?>, Object>[] currentChildOptions;
    final Entry<AttributeKey<?>, Object>[] currentChildAttrs;
    synchronized (childOptions) {
        currentChildOptions = childOptions.entrySet().toArray(newOptionArray(0));
    }
    synchronized (childAttrs) {
        currentChildAttrs = childAttrs.entrySet().toArray(newAttrArray(0));
    }
	
    //1.2 为 NioServerSocketChannel 添加初始化器：初始化器什么时候执行？
    p.addLast(new ChannelInitializer<Channel>() {
        @Override
        public void initChannel(final Channel ch) throws Exception {
            final ChannelPipeline pipeline = ch.pipeline();
            ChannelHandler handler = config.handler();
            if (handler != null) {
                pipeline.addLast(handler);
            }

            //1.2.1 初始化器的职责：将 ServerBootstrapAcceptor 加入至 NioServerSocketChannel
            ch.eventLoop().execute(new Runnable() {
                @Override
                public void run() {
                    pipeline.addLast(new ServerBootstrapAcceptor(
                            ch, currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));
                }
            });
        }
    });
}

    关键代码 io.netty.channel.AbstractChannel.AbstractUnsafe#register：

    • ServerBootStrap—>eventLoopGroup—>eventLoop—>Channel
    //2 注册：切换线程，并将原生 channel 注册到 selector 上
public final void register(EventLoop eventLoop, final ChannelPromise promise) {
    // 一些检查...
    AbstractChannel.this.eventLoop = eventLoop;

    if (eventLoop.inEventLoop()) { //是否是EventLoop线程
        register0(promise);
    } else {
        try {
            //2.1 切换线程
            // 首次执行 execute 方法时：才启动 nio 线程，之后注册等操作在 nio 线程上执行
            // 因为只有一个 NioServerSocketChannel 因此，也只会有一个 boss nio 线程
            eventLoop.execute(new Runnable() {
                @Override
                public void run() {
                    //2.2 将原生 channel 注册到 selector 上
                    register0(promise);
                }
            });
        } catch (Throwable t) {
            // 日志记录...
            closeForcibly();
            closeFuture.setClosed();
            safeSetFailure(promise, t);
        }
    }
}

    io.netty.channel.AbstractChannel.AbstractUnsafe#register0

    //2.2 将原生 channel 注册到 selector 上
private void register0(ChannelPromise promise) {
    try {
        if (!promise.setUncancellable() || !ensureOpen(promise)) {
            return;
        }
        boolean firstRegistration = neverRegistered;
        // 2.2.1 原生的 nio channel 绑定到 selector 上，注意此时没有注册 selector 关注事件，附件为 NioServerSocketChannel
        //this.selectionKey = this.javaChannel().register(this.eventLoop().unwrappedSelector(), 0, this);
        doRegister();
        neverRegistered = false;
        registered = true;

        // 2.2.2 执行 NioServerSocketChannel 初始化器的 initChannel，回到 1.2
        pipeline.invokeHandlerAddedIfNeeded();

        // 2.2.3 设置initAndRegister()执行结果，回到 3.绑定端口号、注册accept事件
        safeSetSuccess(promise);
        pipeline.fireChannelRegistered();
        
        if (isActive()) {// 对应 server socket channel 还未绑定，isActive 为 false
            if (firstRegistration) {
                pipeline.fireChannelActive();
            } else if (config().isAutoRead()) {
                beginRead();
            }
        }
    } catch (Throwable t) {
        closeForcibly();
        closeFuture.setClosed();
        safeSetFailure(promise, t);
    }
}

    关键代码 io.netty.bootstrap.AbstractBootstrap#doBind0

    //3.绑定端口号、触发 active 事件、注册accept事件
private static void doBind0(
        final ChannelFuture regFuture, final Channel channel,
        final SocketAddress localAddress, final ChannelPromise promise) {

    channel.eventLoop().execute(new Runnable() {
        @Override
        public void run() {
            if (regFuture.isSuccess()) {
                channel.bind(localAddress, promise).addListener(ChannelFutureListener.CLOSE_ON_FAILURE);
            } else {
                promise.setFailure(regFuture.cause());
            }
        }
    });
}

    关键代码 io.netty.channel.AbstractChannel.AbstractUnsafe#bind

    //3.绑定端口号、触发 active 事件、注册accept事件
public final void bind(final SocketAddress localAddress, final ChannelPromise promise) {
    assertEventLoop();

    if (!promise.setUncancellable() || !ensureOpen(promise)) {
        return;
    }

    if (Boolean.TRUE.equals(config().getOption(ChannelOption.SO_BROADCAST)) &&
        localAddress instanceof InetSocketAddress &&
        !((InetSocketAddress) localAddress).getAddress().isAnyLocalAddress() &&
        !PlatformDependent.isWindows() && !PlatformDependent.maybeSuperUser()) {// 记录日志...
    }

    boolean wasActive = isActive();
    try {
        //3.1 ServerSocketChannel 绑定端口
        doBind(localAddress);
    } catch (Throwable t) {
        safeSetFailure(promise, t);
        closeIfClosed();
        return;
    }

    if (!wasActive && isActive()) {
        invokeLater(new Runnable() {
            @Override
            public void run() {
                //3.2 触发 active 事件、注册accept事件
                pipeline.fireChannelActive();
            }
        });
    }

    safeSetSuccess(promise);
}

    关键代码 io.netty.channel.socket.nio.NioServerSocketChannel#doBind

    //3.1 ServerSocketChannel 绑定端口
protected void doBind(SocketAddress localAddress) throws Exception {
    if (PlatformDependent.javaVersion() >= 7) {
        javaChannel().bind(localAddress, config.getBacklog());
    } else {
        javaChannel().socket().bind(localAddress, config.getBacklog());
    }
}

    关键代码 io.netty.channel.DefaultChannelPipeline.HeadContext#channelActive

    //3.2 触发 active 事件、注册accept事件
public void channelActive(ChannelHandlerContext ctx) {
    //3.2.1 触发 active 事件
    ctx.fireChannelActive(); 
	//3.2.2 注册accept事件
    readIfIsAutoRead();
}

    关键代码 io.netty.channel.nio.AbstractNioChannel#doBeginRead

    //3.2.2 注册accept事件
protected void doBeginRead() throws Exception {
    // Channel.read() or ChannelHandlerContext.read() was called
    final SelectionKey selectionKey = this.selectionKey;
    if (!selectionKey.isValid()) {
        return;
    }

    readPending = true;

    final int interestOps = selectionKey.interestOps();
    // readInterestOp 取值是 16，在 NioServerSocketChannel 创建时初始化好，代表关注 accept 事件
    if ((interestOps & readInterestOp) == 0) {
        selectionKey.interestOps(interestOps | readInterestOp);
    }
}

    2.2 NioEventLoop 剖析

    NioEventLoop 线程不仅要处理 IO 事件，还要处理 Task（包括普通任务和定时任务），

    • selector：unwrappedSelector（Selector）、selector（SelectedSelectionKeySetSelector）
    • 线程：thread（由executor中唯一的线程赋值）、executor（Executor）
    • 任务队列：taskQueue（Queue）、scheduledTaskQueue（PriorityQueue>）

    1）何时创建selector

    • 在构造方法调用时创建
    /**
 * io.netty.channel.nio.NioEventLoop#NioEventLoop
 */
NioEventLoop(NioEventLoopGroup parent, Executor executor, SelectorProvider selectorProvider, SelectStrategy strategy, RejectedExecutionHandler rejectedExecutionHandler, EventLoopTaskQueueFactory queueFactory) {
        super(parent, executor, false, newTaskQueue(queueFactory), newTaskQueue(queueFactory), rejectedExecutionHandler);
        if (selectorProvider == null) {
            throw new NullPointerException("selectorProvider");
        } else if (strategy == null) {
            throw new NullPointerException("selectStrategy");
        } else {
            this.provider = selectorProvider;
            //在构造方法调用时创建：赋值给unwrappedSelector
            NioEventLoop.SelectorTuple selectorTuple = this.openSelector();
            this.selector = selectorTuple.selector;
            this.unwrappedSelector = selectorTuple.unwrappedSelector;
            this.selectStrategy = strategy;
        }
    }

    2）为什么会有两个selector

    • unwrappedSelector：原始的Selector，将 selectedKeys属性 的Set实现改为了数组（SelectedSelectionKeySet ）的实现
    • selector：SelectedSelectionKeySetSelector 实例，内部包装了 unwrappedSelector 、SelectedSelectionKeySet 数组
    /**
 * io.netty.channel.nio.NioEventLoop#NioEventLoop
 */
NioEventLoop(NioEventLoopGroup parent, Executor executor, SelectorProvider selectorProvider, SelectStrategy strategy, RejectedExecutionHandler rejectedExecutionHandler, EventLoopTaskQueueFactory queueFactory) {
    //1.获取两个Selector
    NioEventLoop.SelectorTuple selectorTuple = this.openSelector();
    //2.赋值
    this.selector = selectorTuple.selector;
    this.unwrappedSelector = selectorTuple.unwrappedSelector;
}
	//1.获取两个Selector
	private NioEventLoop.SelectorTuple openSelector() {
        //引用 unwrappedSelector 中的 selectedKeySet
        this.selectedKeys = selectedKeySet;
	    //...改为了数组实现：数组实现可以提高遍历性能（原本为 HashSet）
	    return new NioEventLoop.SelectorTuple(
	        //原始的Selector
	        unwrappedSelector, 
	        //包装后的Selector
	        new SelectedSelectionKeySetSelector(unwrappedSelector, selectedKeySet)
	    );
	}

    3）thread何时启动

    • 首次调用 execute 方法时,将 executor 中唯一的线程赋值给 thread

    • 执行该线程任务，任务为死循环，不断查看是否有任务（调用selector.select(timeoutMills)）

      /**
 * io.netty.util.concurrent.SingleThreadEventExecutor#execute
 */
public void execute(Runnable task) 
    // 添加任务，其中队列使用了 jctools 提供的 mpsc 无锁队列
    this.addTask(task);
	//1.首次调用，启动线程
    this.startThread();
	//2.添加任务后执行wakeup
	if (!this.addTaskWakesUp && this.wakesUpForTask(task)) {
	    this.wakeup(inEventLoop);
	}
}
	//1.首次调用，启动线程
    private void startThread() {
        this.doStartThread();
    }
    	private void doStartThread() {
       		this.executor.execute(new Runnable() {
                //1.将 executor 中唯一的线程赋值给 thread
                SingleThreadEventExecutor.this.thread = Thread.currentThread();
                //2.执行该线程的 run 方法，进入死循环
                SingleThreadEventExecutor.this.run();
            }     
    	}
    				//2.执行thread任务：执行死循环，不断看有没有新任务、IO 事件 。循环+阻塞
    				protected void run() {
    				    while(true) {
    				        while(true) {
    				            while(true) {
    				                try {
    				                    try {
    				                        switch() {
    				                        case -3:
    				                        case -1:
    				                            //1.调用select
    				                            this.select(this.wakenUp.getAndSet(false));
    				                            if (this.wakenUp.get()) {
    				                                this.selector.wakeup();
    				                            }
    				                            break;
    				                        case -2:
    				                            continue;
    				                        }
    				                    }
                                        //...执行任务
    				                } 
    				            }
    				        }
    				    }
    				}
					    //1.调用select
					    private void select(boolean oldWakenUp) throws IOException {
					        try {
					            while(true) {
					                //2.阻塞
					                int selectedKeys = selector.select(timeoutMillis);
					            }
					        } catch (CancelledKeyException var13) {}
					    }

    4）普通任务会不会结束 select 阻塞

    • 会。非Nio线程每次调用 execute 方法后，会执行一次 wakeup

      /**
 * io.netty.util.concurrent.SingleThreadEventExecutor#execute
 */
public void execute(Runnable task) 
    this.addTask(task);
    this.startThread();
	//1.添加任务后执行wakeup
	if (!this.addTaskWakesUp && this.wakesUpForTask(task)) {
	    this.wakeup(inEventLoop);
	}
}
    protected void wakeup(boolean inEventLoop) {
        // 如果线程由于 IO select 阻塞了，添加的任务的线程需要负责唤醒 NioEventLoop 线程
        if (!inEventLoop && this.wakenUp.compareAndSet(false, true)) {
            this.selector.wakeup();
        }
    }

    5）普通任务 wakeup 理解

    /**
 * io.netty.channel.nio.NioEventLoop#wakeup
 */
protected void wakeup(boolean inEventLoop) {
    //1.提交任务的线程不是Nio线程才会进入if块
    //2.保证多个非Nio线程同时提交任务后只唤醒一次
    if (!inEventLoop && this.wakenUp.compareAndSet(false, true)) {
        this.selector.wakeup();
    }
}

    6）thread什么时候 select

    • 没有任务时：返回-1，进入阻塞逻辑
    • 有任务时：调用 selectNow(返回0-…) 顺便拿到io 事件，执行任务
    /**
 * io.netty.channel.nio.NioEventLoop#run
 */
//执行死循环，不断看有没有新任务、IO 事件 。循环+阻塞
protected void run() {
    while(true) {
        while(true) {
            while(true) {
                try {
                    try {
                        //1.当返回-1时进入阻塞逻辑
                        switch(this.selectStrategy.calculateStrategy(this.selectNowSupplier, this.hasTasks())) {
                        case -3:
                        case -1:
                            //进入 select 逻辑
                            this.select(this.wakenUp.getAndSet(false));
                            if (this.wakenUp.get()) {
                                this.selector.wakeup();
                            }
                            break;
                        case -2:
                            continue;
                        }
                    }
                    //...执行任务
                } 
            }
        }
    }
}
	//1.没有任务时返回-1，进入阻塞逻辑
    public int calculateStrategy(IntSupplier selectSupplier, boolean hasTasks) throws Exception {
        return hasTasks ? selectSupplier.get() : -1;
    } 
		//2.有任务时调用 selectNow(返回0-...) 顺便拿到io 事件
    	private final IntSupplier selectNowSupplier = new IntSupplier() {
    	    public int get() throws Exception {
    	        return NioEventLoop.this.selectNow();
    	    }
    	};

    7）select 阻塞多久

    • 超时时间：（1s+0.5ms）/1ms = 1000ms
    • 退出阻塞：到达截至时间（1s）、存在普通任务、发生io事件、被唤醒、被打断
    /**
 *	io.netty.channel.nio.NioEventLoop#select
 */
//进入 select 逻辑
private void select(boolean oldWakenUp) throws IOException {
    //1.获取当前时间
    long currentTimeNanos = System.nanoTime();
    //2.没有定时任务，截至时间：当前时间 + 1s
    //2.存在定时任务，截至时间：下一个定时任务执行时间 - 当前时间
    long selectDeadLineNanos = currentTimeNanos + this.delayNanos(currentTimeNanos);
    //截至时间不变，当前时间改变
    while(true) {
        //3.超时时间：（1s+0.0005s）/1ms = 1000ms
        long timeoutMillis = (selectDeadLineNanos - currentTimeNanos + 500000L) / 1000000L;
        //到达截至时间：退出阻塞
        if (timeoutMillis <= 0L) {
            if (selectCnt == 0) {
                selector.selectNow();
                selectCnt = 1;
            }
            break;
        }
        //有普通任务：退出阻塞。如果没这个判断，那么任务就会等到下次 select 超时时才能被执行
        if (this.hasTasks() && this.wakenUp.compareAndSet(false, true)) {
            selector.selectNow();
            selectCnt = 1;
            break;
        }
        int selectedKeys = selector.select(timeoutMillis);
        //醒来后，有 IO 事件、非 EventLoop 线程唤醒、有任务：退出阻塞
        if (selectedKeys != 0 || oldWakenUp || this.wakenUp.get() || this.hasTasks() || this.hasScheduledTasks()) {
                    break;
        }
        
        long time = System.nanoTime();
        currentTimeNanos = time;
    }
}
	//2.获取截至时间
    protected long delayNanos(long currentTimeNanos) {
        ScheduledFutureTask<?> scheduledTask = this.peekScheduledTask(); //不考虑
        return scheduledTask == null ? SCHEDULE_PURGE_INTERVAL : scheduledTask.delayNanos(currentTimeNanos);
    }
		static {
        	SCHEDULE_PURGE_INTERVAL = TimeUnit.SECONDS.toNanos(1L);
    	}

    8）BUG解决：select空轮询

    • BUG解释：即 select 不阻塞（jdk 在linux中才会出现）
    • BUG解决：空轮询超过阈值（默认512），重建、替换旧的 selector，并退出阻塞
    /**
 *	io.netty.channel.nio.NioEventLoop#select
 */
private void select(boolean oldWakenUp) throws IOException {
    try {
        int selectCnt = 0;
        //1.循环+阻塞：如果出现bug没阻塞即空轮询，则 selectCnt++
        while(true) {
            int selectedKeys = selector.select(timeoutMillis);
            ++selectCnt;
            //2.selectCnt超出阈值：重建并替换旧的 selector，退出阻塞
            else if (SELECTOR_AUTO_REBUILD_THRESHOLD > 0 && selectCnt >= SELECTOR_AUTO_REBUILD_THRESHOLD) {
                selector = this.selectRebuildSelector(selectCnt);
                selectCnt = 1;
                break;
            }
        }
    } 
}
static {
    //3.阈值默认值：512
    int selectorAutoRebuildThreshold = SystemPropertyUtil.getInt("io.netty.selectorAutoRebuildThreshold", 512);
    if (selectorAutoRebuildThreshold < 3) {
        selectorAutoRebuildThreshold = 0;
    }
    SELECTOR_AUTO_REBUILD_THRESHOLD = selectorAutoRebuildThreshold;
}

    9）thread 执行任务

    • 有多少任务执行多少任务
    • 按时间比例执行任务
      • 各占50%：io任务执行多久，普通任务就执行多久
    /**
 *	io.netty.channel.nio.NioEventLoop#run
 */
//设置执行io任务的时间比例50%
private volatile int ioRatio = 50;
//执行死循环，不断看有没有新任务、IO 事件 。循环+阻塞
protected void run() {
    while(true) {
        while(true) {
            while(true) {
                try {
                    int ioRatio = this.ioRatio;
                    //1.比例设置为 100：则时间分配无效，该次循环存在多少任务执行多少任务
                    if (ioRatio == 100) {
                        try {
                            this.processSelectedKeys();
                        } finally {
                            this.runAllTasks();
                        }
                    } 
                    //2.按时间比例执行任务
                    else {
                        long ioStartTime = System.nanoTime();
                        boolean var14 = false;
                        try {
                            var14 = true;
                            this.processSelectedKeys();
                            var14 = false;
                        } finally {
                            if (var14) {
                                long ioTime = System.nanoTime() - ioStartTime;、
                                this.runAllTasks(ioTime * (long)(100 - ioRatio) / (long)ioRatio);
                            }
                        }
                        //2.1 获取 io任务 执行所用时间
                        //2.2 执行普通任务：所用时间与 io任务 相同
                        long ioTime = System.nanoTime() - ioStartTime;
                        this.runAllTasks(ioTime * (long)(100 - ioRatio) / (long)ioRatio);
                    }
                }
            }
        }
    }
}

    10）区分不同事件

    /**
 *	io.netty.channel.nio.NioEventLoop#run
 */
//1.执行io任务
protected void run() {
    while(true) {
        while(true) {
            while(true) {
                try {
                    else {
                        try {
                            this.processSelectedKeys();
                        }
                    }
                }
            }
        }
    }
}
    private void processSelectedKeys() {
        //2.如果selectedKeySet已替换为数组实现
        //数组实现可以提高遍历性能（原本为 HashSet）
        if (this.selectedKeys != null) {
            this.processSelectedKeysOptimized();
        }
    }
    	private void processSelectedKeysOptimized() {
    	    for(int i = 0; i < this.selectedKeys.size; ++i) {
    	        SelectionKey k = this.selectedKeys.keys[i];
    	        this.selectedKeys.keys[i] = null;
    	        //3.获得事件相关的 Channel
    	        Object a = k.attachment();
    	        if (a instanceof AbstractNioChannel) {
    	            this.processSelectedKey(k, (AbstractNioChannel)a);
    	        } 
    	    }
    	}
			//4.根据事件类型执行任务
    		private void processSelectedKey(SelectionKey k, AbstractNioChannel ch) {
    		    NioUnsafe unsafe = ch.unsafe();
    		    if (!k.isValid()) {}
    		    //key有效
    		    else {
    		        try {
    		            int readyOps = k.readyOps();
                        //连接事件
    		            if ((readyOps & 8) != 0) {
    		                int ops = k.interestOps();
    		                ops &= -9;
    		                k.interestOps(ops);
    		                unsafe.finishConnect();
    		            }
                        //可写事件
    		            if ((readyOps & 4) != 0) {
    		                ch.unsafe().forceFlush();
    		            }
                        //可读、可接入事件
    		            if ((readyOps & 17) != 0 || readyOps == 0) {
                            // 如果是可接入 io.netty.channel.nio.AbstractNioMessageChannel.NioMessageUnsafe#read
            				// 如果是可读 io.netty.channel.nio.AbstractNioByteChannel.NioByteUnsafe#read
    		                unsafe.read();
    		            }
    		        }
    		    }
    		}
    ⚠️ 注意

    这里有个费解的地方就是 wakeup，它既可以由提交任务的线程来调用（比较好理解），也可以由 EventLoop 线程来调用（比较费解），这里要知道 wakeup 方法的效果：

    • 由非 EventLoop 线程调用，会唤醒当前在执行 select 阻塞的 EventLoop 线程
    • 由 EventLoop 自己调用，本次的 wakeup 会取消下一次的 select 操作

    【NIO与Netty】Netty优化与源码_第2张图片

    2.3 accept 剖析

    nio 流程总览

    //1 阻塞直到事件发生
selector.select();

Iterator<SelectionKey> iter = selector.selectedKeys().iterator();
while (iter.hasNext()) {    
    //2 拿到一个事件
    SelectionKey key = iter.next();
    
    //3 如果是 accept 事件
    if (key.isAcceptable()) {
        
        //4 执行 accept
        SocketChannel channel = serverSocketChannel.accept();
        channel.configureBlocking(false);
        
        //5 关注 read 事件
        channel.register(selector, SelectionKey.OP_READ);
    }
    // ...
}

    启动跟源码

    服务器入口io.netty.channel.nio.NioEventLoop#processSelectedKey

    /**
 * io.netty.channel.nio.AbstractNioMessageChannel.NioMessageUnsafe#read
 */
public void read() {
    try {
        try {
            do {
                //1.ServerScoketChannel 执行 accept 创建 SocketChannel
				//2.将 SocketChannel 包装为 NioSocketChannel、设置非阻塞，然后将 SocketChannel 作为消息放入 readBuf
                int localRead = doReadMessages(readBuf);
                if (localRead == 0) {
                    break;
                }
                if (localRead < 0) {
                    closed = true;
                    break;
                }
				// localRead 为 1，就一条消息，即接收一个客户端连接
                allocHandle.incMessagesRead(localRead);
            } while (allocHandle.continueReading());
        } catch (Throwable t) {
            exception = t;
        }

        int size = readBuf.size();
        for (int i = 0; i < size; i ++) {
            readPending = false;
            //3.进入 NioServerSocketChannel 的流水线：
            // 触发 read 事件，让 pipeline 上的 handler 处理
            pipeline.fireChannelRead(readBuf.get(i));
        }
        readBuf.clear();
        allocHandle.readComplete();
        pipeline.fireChannelReadComplete();

        if (exception != null) {
            closed = closeOnReadError(exception);

            pipeline.fireExceptionCaught(exception);
        }

        if (closed) {
            inputShutdown = true;
            if (isOpen()) {
                close(voidPromise());
            }
        }
    } finally {
        if (!readPending && !config.isAutoRead()) {
            removeReadOp();
        }
    }
}
	//1.
	//2.
	protected int doReadMessages(List<Object> buf) throws Exception {
        //1.ServerScoketChannel 执行 accept 创建 SocketChannel
        SocketChannel ch = SocketUtils.accept(this.javaChannel());
        try {
            if (ch != null) {
                //2.将 SocketChannel 包装为 NioSocketChannel、设置非阻塞，然后将 SocketChannel 作为消息放入 readBuf
                buf.add(new NioSocketChannel(this, ch));
                return 1;
            }
        }
        return 0;
    }
		//1.ServerScoketChannel 执行 accept 创建 SocketChannel
    	public static SocketChannel accept(final ServerSocketChannel serverSocketChannel) throws IOException {
    	    try {
    	        return (SocketChannel)AccessController.doPrivileged(new PrivilegedExceptionAction<SocketChannel>() {
    	            public SocketChannel run() throws IOException {
    	                return serverSocketChannel.accept();
    	            }
    	        });
    	    }
    	}

    关键代码 io.netty.bootstrap.ServerBootstrap.ServerBootstrapAcceptor#channelRead

    //3.进入 NioServerSocketChannel 的流水线
public void channelRead(ChannelHandlerContext ctx, Object msg) {
    
    final Channel child = (Channel) msg; // 这时的 msg 是 NioSocketChannel

    child.pipeline().addLast(childHandler); // NioSocketChannel 添加  childHandler 即初始化器

    setChannelOptions(child, childOptions, logger); // 设置选项

    for (Entry<AttributeKey<?>, Object> e: childAttrs) {
        child.attr((AttributeKey<Object>) e.getKey()).set(e.getValue());
    }

    try {
        //4.将 NioSocketChannel 注册到新的 NioEventLoop 线程中
        childGroup.register(child).addListener(new ChannelFutureListener() {
            @Override
            public void operationComplete(ChannelFuture future) throws Exception {
                if (!future.isSuccess()) {
                    forceClose(child, future.cause());
                }
            }
        });
    } catch (Throwable t) {
        forceClose(child, t);
    }
}

    又回到启动剖析中熟悉的 io.netty.channel.AbstractChannel.AbstractUnsafe#register 方法

    //4.切换线程：异步将 NioSocketChannel 注册到新的 NioEventLoop 线程中
public final void register(EventLoop eventLoop, final ChannelPromise promise) {
    // 一些检查...
    AbstractChannel.this.eventLoop = eventLoop;

    if (eventLoop.inEventLoop()) { //是否是EventLoop线程
        register0(promise);
    } else {
        try {
            //4.1 切换线程：这行代码完成的事实是 nio boss -> nio worker 线程的切换
            // 首次执行 execute 方法时：才启动 nio 线程，之后注册等操作在 nio 线程上执行
            eventLoop.execute(new Runnable() {
                @Override
                public void run() {
                    //4.2 将 NioSocketChannel 注册到新的 NioEventLoop 线程中
                    register0(promise);
                }
            });
        }
        //...
    }
}

    io.netty.channel.AbstractChannel.AbstractUnsafe#register0

    //4.2 将 NioSocketChannel 注册到新的 NioEventLoop 线程中
private void register0(ChannelPromise promise) {
    try {
        if (!promise.setUncancellable() || !ensureOpen(promise)) {
            return;
        }
        boolean firstRegistration = neverRegistered;
        // 4.2.1 将 NioSocketChannel 注册到新的 selector 上
        // 注意此时没有注册 selector 关注事件，附件为当前的 NioSocketChannel
        // this.selectionKey = this.javaChannel().register(this.eventLoop().unwrappedSelector(), 0, this);
        doRegister();
        neverRegistered = false;
        registered = true;
		
        //4.2.2 执行初始化器：我们给NioSocketChannel写的 chileHandler—>initChannel
        //执行前 pipeline 中只有 head -> 初始化器 -> tail
        pipeline.invokeHandlerAddedIfNeeded();
        //执行后就是 head -> logging handler -> tail

        safeSetSuccess(promise);
        pipeline.fireChannelRegistered();
        
        if (isActive()) {
            if (firstRegistration) {
                //4.2.3 在新的 selector 上关注 read 事件
                // 触发 pipeline 上 active 事件
                pipeline.fireChannelActive();
            } else if (config().isAutoRead()) {
                beginRead();
            }
        }
    } catch (Throwable t) {
        closeForcibly();
        closeFuture.setClosed();
        safeSetFailure(promise, t);
    }
}
	//4.2.2 执行初始化器：我们给NioSocketChannel写的 chileHandler—>initChannel
    public static void main(String[] args) {
        NioEventLoopGroup group = new NioEventLoopGroup(2);
        try {
            Channel channel = new ServerBootstrap()
                    .childHandler(new ChannelInitializer<NioSocketChannel>() {
                        @Override
                        protected void initChannel(NioSocketChannel channel) throws Exception {
                            //添加日志处理器
                            channel.pipeline().addLast(new LoggingHandler());
                        }
                    })
                //...
        }
    }

    回到了熟悉的代码 io.netty.channel.DefaultChannelPipeline.HeadContext#channelActive

    //4.2.3 在新的 selector 上关注 read 事件
public void channelActive(ChannelHandlerContext ctx) {
    ctx.fireChannelActive();
    //关注 read 事件(NioSocketChannel 这里 read，只是为了触发 channel 的事件注册，还未涉及数据读取)
    this.readIfIsAutoRead();
}

    io.netty.channel.nio.AbstractNioChannel#doBeginRead

    //关注 read 事件
protected void doBeginRead() throws Exception {
    SelectionKey selectionKey = this.selectionKey;
    if (selectionKey.isValid()) {
        this.readPending = true;
        int interestOps = selectionKey.interestOps();//这时候 interestOps 是 0
        if ((interestOps & this.readInterestOp) == 0) {
            //关注 read 事件
            selectionKey.interestOps(interestOps | this.readInterestOp);
        }
    }
}

    2.4 read 剖析

    再来看可读事件 io.netty.channel.nio.AbstractNioByteChannel.NioByteUnsafe#read，注意发送的数据未必能够一次读完，因此会触发多次 nio read 事件，一次事件内会触发多次 pipeline read，一次事件会触发一次 pipeline read complete

    public final void read() {
    final ChannelConfig config = config();
    if (shouldBreakReadReady(config)) {
        clearReadPending();
        return;
    }
    final ChannelPipeline pipeline = pipeline();
    //1.获取 byteBuf 分配器：决定是池化还是非池化的
    // io.netty.allocator.type 决定 allocator 的实现
    final ByteBufAllocator allocator = config.getAllocator();
    //2.动态调整 byteBuf 的分配大小，并且强制使用直接内存
    final RecvByteBufAllocator.Handle allocHandle = recvBufAllocHandle();
    a llocHandle.reset(config);

    ByteBuf byteBuf = null;
    boolean close = false;
    try {
        do {
            byteBuf = allocHandle.allocate(allocator);
            //3.读取到 byteBuf
            allocHandle.lastBytesRead(doReadBytes(byteBuf));
            if (allocHandle.lastBytesRead() <= 0) {
                byteBuf.release();
                byteBuf = null;
                close = allocHandle.lastBytesRead() < 0;
                if (close) {
                    readPending = false;
                }
                break;
            }

            allocHandle.incMessagesRead(1);
            readPending = false;
            //4.触发 read 事件，把 ByteBuf 依次传给流水线中的handler 处理，这时是处理 NioSocketChannel 上的 handler
            pipeline.fireChannelRead(byteBuf);
            byteBuf = null;
        } 
        //5.是否要继续循环
        while (allocHandle.continueReading());

        allocHandle.readComplete();
        // 触发 read complete 事件
        pipeline.fireChannelReadComplete();

        if (close) {
            closeOnRead(pipeline);
        }
    } catch (Throwable t) {
        handleReadException(pipeline, byteBuf, t, close, allocHandle);
    } finally {
        if (!readPending && !config.isAutoRead()) {
            removeReadOp();
        }
    }
}

    io.netty.channel.DefaultMaxMessagesRecvByteBufAllocator.MaxMessageHandle#continueReading(io.netty.util.UncheckedBooleanSupplier)

    //5.是否要继续循环
public boolean continueReading(UncheckedBooleanSupplier maybeMoreDataSupplier) {
    return 
           // 一般为 true
           config.isAutoRead() &&
           // respectMaybeMoreData 默认为 true
           // maybeMoreDataSupplier 的逻辑是如果预期读取字节与实际读取字节相等，返回 true
           (!respectMaybeMoreData || maybeMoreDataSupplier.get()) &&
           // 小于最大次数，maxMessagePerRead 默认 16
           totalMessages < maxMessagePerRead &&
           // 实际读到了数据
           totalBytesRead > 0;
}

    你可能感兴趣的:(#,NIO,与,Netty,java,nio,服务器,网络)

    • 斤斤计较的婚姻到底有多难？ 白心之岂必有为
      很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
    • QQ群采集助手，精准引流必备神器 2401_87347160 其他经验分享
      功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
    • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
      一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
    • 随笔 | 仙一般的灵气 海思沧海
      仙岛今天，我看了你全部，似乎已经进入你的世界我不知道，这是否是梦幻，还是你仙一般的灵气吸引了我也许每一个人都要有一份属于自己的追求，这样才能够符合人生的梦想，生活才能够充满着阳光与快乐我不知道，我为什么会这样的感叹，是在感叹自己的人生，还是感叹自己一直没有孜孜不倦的追求只感觉虚度了光阴，每天活在自己的梦中，活在一个不真实的世界是在逃避自己，还是在逃避周围的一切有时候我嘲笑自己，嘲笑自己如此的虚无，
    • 一百九十四章. 自相矛盾 巨木擎天
      唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
    • 微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务java架构
      在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
    • 理解Gunicorn：Python WSGI服务器的基石 范范0825 ipythonlinux运维
      理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
    • 学点心理知识，呵护孩子健康 静候花开_7090
      昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
    • 《投行人生》读书笔记 小蘑菇的树洞
      《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
    • Long类型前后端数据不一致 igotyback 前端
      响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    • LocalDateTime 转 String igotyback java开发语言
      importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
    • swagger访问路径 igotyback swagger
      Swagger2.x版本访问地址：http://{ip}:{port}/{context-path}/swagger-ui.html{ip}是你的服务器IP地址。{port}是你的应用服务端口，通常为8080。{context-path}是你的应用上下文路径，如果应用部署在根路径下，则为空。Swagger3.x版本对于Swagger3.x版本（也称为OpenAPI3）访问地址：http://{ip
    • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
      需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码 说私域 人工智能小程序
      摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
    • 2021-08-26 影幽
      在生活中，女人与男人的感悟往往有所不同。人生最大的舞台就是生活，大幕随时都可能拉开，关键是你愿不愿意表演都无法躲避。在生活中，遇事不要急躁，不要急于下结论，尤其生气时不要做决断，要学会换位思考，大事化小小事化了，把复杂的事情尽量简单处理，千万不要把简单的事情复杂化。永远不要扭曲，别人善意，无药可救。昨天是张过期的支票，明天是张信用卡，只有今天才是现金，要善加利用！执着的攀登者不必去与别人比较自己的
    • 高级编程--XML+socket练习题 masa010 java开发语言
      1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
    • 2018-07-23-催眠日作业-#不一样的31天#-66小鹿 小鹿_33
      预言日：人总是在逃避命运的路上，与之不期而遇。心理学上有个著名的名词，叫做自证预言；经济学上也有一个很著名的定律叫做，墨菲定律；在灵修派上，还有一个很著名的法则，叫做吸引力法则。这3个领域的词，虽然看起来不太一样，但是他们都在告诉人们一个现象：你越担心什么，就越有可能会发生什么。同样的道理，你越想得到什么，就应该要积极地去创造什么。无论是自证预言，墨菲定律还是吸引力法则，对人都有正反2个维度的影响
    • 回溯 Leetcode 332 重新安排行程 mmaerd Leetcode刷题学习记录leetcode算法职场和发展
      重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
    • 每日一题——第九十题 互联网打工人no1 C语言程序设计每日一练c语言
      题目：判断子串是否与主串匹配#include#include#include//////判断子串是否在主串中匹配//////主串///子串///boolisSubstring(constchar*str,constchar*substr){intlenstr=strlen(str);//计算主串的长度intlenSub=strlen(substr);//计算子串的长度//遍历主字符串，对每个可能得
    • Python数据分析与可视化实战指南 William数据分析 pythonpython数据
      在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
    • 《庄子.达生9》 钱江潮369
      【原文】孔子观于吕梁，县水三十仞，流沫四十里，鼋鼍鱼鳖之所不能游也。见一丈夫游之，以为有苦而欲死也，使弟子并流而拯之。数百步而出，被发行歌而游于塘下。孔子从而问焉，曰：“吾以子为鬼，察子则人也。请问，‘蹈水有道乎’”曰：“亡，吾无道。吾始乎故，长乎性，成乎命。与齐俱入，与汩偕出，从水之道而不为私焉。此吾所以蹈之也。”孔子曰：“何谓始乎故，长乎性，成乎命？”曰：“吾生于陵而安于陵，故也；长于水而安于
    • 水泥质量纠纷案代理词 徐宝峰律师
      贵州领航建设有限公司诉贵州纳雍隆庆乌江水泥有限公司产品质量纠纷案代理词尊敬的审判长、审判员：贵州千里律师事务所接受被告贵州纳雍隆庆乌江水泥有限公司的委托，指派我担任其诉讼代理人，参加本案的诉讼活动。下面，我结合本案事实和相关法律规定发表如下代理意见，供合议庭评议案件时参考：原告应当举证证明其遭受的损失与被告生产的水泥质量的因果关系。首先水泥是一种粉状水硬性无机胶凝材料。加水搅拌后成浆体，能在空气中
    • Goolge earth studio 进阶4——路径修改与平滑 陟彼高冈yu Googleearthstudio进阶教程旅游
      如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
    • PHP环境搭建详细教程 好看资源平台 前端php
      PHP是一个流行的服务器端脚本语言，广泛用于Web开发。为了使PHP能够在本地或服务器上运行，我们需要搭建一个合适的PHP环境。本教程将结合最新资料，介绍在不同操作系统上搭建PHP开发环境的多种方法，包括Windows、macOS和Linux系统的安装步骤，以及本地和Docker环境的配置。1.PHP环境搭建概述PHP环境的搭建主要分为以下几类：集成开发环境：例如XAMPP、WAMP、MAMP，这
    • 基于社交网络算法优化的二维最大熵图像分割 智能算法研学社（Jack旭） 智能优化算法应用图像分割算法php开发语言
      智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
    • 使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器） 编程经验分享 开发工具服务器sshlinux
      目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
    • 18-115 一切思考不能有效转化为行动，都TM是扯淡！ 成长时间线
      7月25号写了一篇关于为什么会断更如此严重的反思，然而，之后日更仅仅维持了一周，又出现了这次更严重的现象。从8月2号到昨天8月6号，5天！又是5天没有更文！虽然这次断更时间和上次一样，那为什么说这次更严重？因为上次之后就分析了问题的原因，以及应该如何解决，按理说应该会好转，然而，没过几天严重断更的现象再次出现，想想，经过反思，问题依然没有解决与改变，这让我有些担忧。到底是哪里出了问题，难道我就真的
    • 山东大学小树林支教调研团青青仓木队——翟晓楠 山东大学青青仓木队
      过了半年，又一次启程，又一次回到支教的初心之地。比起上一次的试探与不安，我更多了一丝稳重与熟练。心境、处境也都随着半个学期的过去而变得不同，半个学期中，身体上的，心理上的，太多的逆境让我变得步履维艰，曲曲折折，弯弯绕绕，我仿佛打不起精神，没有胃口，没有动力。感觉走的不顺畅的时候，支教这个旅程，给了我力量。自告奋勇承担起队长这一职务的我，从组织时的复杂和困难的经历，协调各种问题，从无到有，和校长和队
    • 直返最高等级与直返APP：无需邀请码的返利新体验 古楼
      随着互联网的普及和电商的兴起，直返模式逐渐成为一种流行的商业模式。在这种模式下，消费者通过购买产品或服务，获得一定的返利，并可以分享给更多的人。其中，直返最高等级和直返APP是直返模式中的重要概念和工具。本文将详细介绍直返最高等级的概念、直返APP的使用以及与邀请码的关系。【高省】APP（高佣金领导者）是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，运行三年，稳定可靠。高省APP，
    • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
      ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    • 关于旗正规则引擎中的MD5加密问题 何必如此 jspMD5规则加密
      一般情况下，为了防止个人隐私的泄露，我们都会对用户登录密码进行加密，使数据库相应字段保存的是加密后的字符串，而非原始密码。 在旗正规则引擎中，通过外部调用，可以实现MD5的加密，具体步骤如下： 1.在对象库中选择外部调用，选择“com.flagleader.util.MD5”，在子选项中选择“com.flagleader.util.MD5.getMD5ofStr({arg1})”； 2.在规
    • 【Spark101】Scala Promise/Future在Spark中的应用 bit1129 Promise
      Promise和Future是Scala用于异步调用并实现结果汇集的并发原语，Scala的Future同JUC里面的Future接口含义相同，Promise理解起来就有些绕。等有时间了再仔细的研究下Promise和Future的语义以及应用场景，具体参见Scala在线文档：http://docs.scala-lang.org/sips/completed/futures-promises.html
    • spark sql 访问hive数据的配置详解 daizj spark sqlhivethriftserver
      spark sql 能够通过thriftserver 访问hive数据，默认spark编译的版本是不支持访问hive，因为hive依赖比较多，因此打的包中不包含hive和thriftserver,因此需要自己下载源码进行编译，将hive，thriftserver打包进去才能够访问，详细配置步骤如下：   1、下载源码   2、下载Maven,并配置 此配置简单，就略过
    • HTTP 协议通信 周凡杨 javahttpclienthttp通信
                              一：简介  HTTPCLIENT，通过JAVA基于HTTP协议进行点与点间的通信！     二： 代码举例      测试类： import java
    • java unix时间戳转换 g21121 java
      把java时间戳转换成unix时间戳： Timestamp appointTime=Timestamp.valueOf(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())) SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:m
    • web报表工具FineReport常用函数的用法总结（报表函数） 老A不折腾 web报表finereport总结
      说明：本次总结中，凡是以tableName或viewName作为参数因子的。函数在调用的时候均按照先从私有数据源中查找，然后再从公有数据源中查找的顺序。   CLASS CLASS(object):返回object对象的所属的类。   CNMONEY CNMONEY(number,unit)返回人民币大写。 number:需要转换的数值型的数。 unit:单位，
    • java jni调用c++ 代码 报错 墙头上一根草 javaC++jni
      # # A fatal error has been detected by the Java Runtime Environment: # #  EXCEPTION_ACCESS_VIOLATION (0xc0000005) at pc=0x00000000777c3290, pid=5632, tid=6656 # # JRE version: Java(TM) SE Ru
    • Spring中事件处理de小技巧 aijuans springSpring 教程Spring 实例Spring 入门Spring3
      Spring 中提供一些Aware相关de接口，BeanFactoryAware、 ApplicationContextAware、ResourceLoaderAware、ServletContextAware等等，其中最常用到de匙ApplicationContextAware.实现ApplicationContextAwaredeBean，在Bean被初始后，将会被注入 Applicati
    • linux shell ls脚本样例 annan211 linuxlinux ls源码linux 源码
      #! /bin/sh - #查找输入文件的路径 #在查找路径下寻找一个或多个原始文件或文件模式 # 查找路径由特定的环境变量所定义 #标准输出所产生的结果 通常是查找路径下找到的每个文件的第一个实体的完整路径 # 或是filename :not found 的标准错误输出。 #如果文件没有找到 则退出码为0 #否则 即为找不到的文件个数 #语法 pathfind [--
    • List,Set,Map遍历方式 (收集的资源,值得看一下) 百合不是茶 listsetMap遍历方式
      List特点：元素有放入顺序，元素可重复 Map特点：元素按键值对存储，无放入顺序 Set特点：元素无放入顺序，元素不可重复（注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的） List接口有三个实现类：LinkedList，ArrayList，Vector LinkedList：底层基于链表实现，链表内存是散乱的，每一个元素存储本身
    • 解决SimpleDateFormat的线程不安全问题的方法 bijian1013 javathread线程安全
      在Java项目中，我们通常会自己写一个DateUtil类，处理日期和字符串的转换，如下所示： public class DateUtil01 { private SimpleDateFormat dateformat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); public void format(Date d
    • http请求测试实例（采用fastjson解析） bijian1013 http测试
              在实际开发中，我们经常会去做http请求的开发，下面则是如何请求的单元测试小实例，仅供参考。 import java.util.HashMap; import java.util.Map; import org.apache.commons.httpclient.HttpClient; import
    • 【RPC框架Hessian三】Hessian 异常处理 bit1129 hessian
      RPC异常处理概述   RPC异常处理指是，当客户端调用远端的服务，如果服务执行过程中发生异常，这个异常能否序列到客户端？   如果服务在执行过程中可能发生异常，那么在服务接口的声明中，就该声明该接口可能抛出的异常。   在Hessian中，服务器端发生异常，可以将异常信息从服务器端序列化到客户端，因为Exception本身是实现了Serializable的
    • 【日志分析】日志分析工具 bit1129 日志分析
      1. 网站日志实时分析工具 GoAccess http://www.vpsee.com/2014/02/a-real-time-web-log-analyzer-goaccess/ 2. 通过日志监控并收集 Java 应用程序性能数据(Perf4J) http://www.ibm.com/developerworks/cn/java/j-lo-logforperf/ 3.log.io 和
    • nginx优化加强战斗力及遇到的坑解决 ronin47 nginx 优化
      　　　先说遇到个坑，第一个是负载问题，这个问题与架构有关，由于我设计架构多了两层，结果导致会话负载只转向一个。解决这样的问题思路有两个：一是改变负载策略，二是更改架构设计。 　　　由于采用动静分离部署，而nginx又设计了静态，结果客户端去读nginx静态，访问量上来，页面加载很慢。解决：二者留其一。最好是保留apache服务器。   　　　来以下优化：   　　　
    • java-50-输入两棵二叉树A和B，判断树B是不是A的子结构 bylijinnan java
      思路来自： http://zhedahht.blog.163.com/blog/static/25411174201011445550396/ import ljn.help.*; public class HasSubtree { /**Q50. * 输入两棵二叉树A和B，判断树B是不是A的子结构。 例如，下图中的两棵树A和B，由于A中有一部分子树的结构和B是一
    • mongoDB 备份与恢复 开窍的石头 mongDB备份与恢复
      Mongodb导出与导入 1: 导入/导出可以操作的是本地的mongodb服务器,也可以是远程的. 所以,都有如下通用选项: -h host   主机 --port port    端口 -u username 用户名 -p passwd   密码 2: mongoexport 导出json格式的文件
    • [网络与通讯]椭圆轨道计算的一些问题 comsci 网络
           如果按照中国古代农历的历法，现在应该是某个季节的开始，但是由于农历历法是3000年前的天文观测数据，如果按照现在的天文学记录来进行修正的话，这个季节已经过去一段时间了。。。。。       也就是说，还要再等3000年。才有机会了，太阳系的行星的椭圆轨道受到外来天体的干扰，轨道次序发生了变
    • 软件专利如何申请 cuiyadll 软件专利申请
      软件技术可以申请软件著作权以保护软件源代码，也可以申请发明专利以保护软件流程中的步骤执行方式。专利保护的是软件解决问题的思想，而软件著作权保护的是软件代码（即软件思想的表达形式）。例如，离线传送文件，那发明专利保护是如何实现离线传送文件。基于相同的软件思想，但实现离线传送的程序代码有千千万万种，每种代码都可以享有各自的软件著作权。申请一个软件发明专利的代理费大概需要5000-8000申请发明专利可
    • Android学习笔记 darrenzhu android
      1.启动一个AVD 2.命令行运行adb shell可连接到AVD,这也就是命令行客户端 3.如何启动一个程序   am start -n package name/.activityName   am start -n com.example.helloworld/.MainActivity 启动Android设置工具的命令如下所示： # am start -
    • apache虚拟机配置，本地多域名访问本地网站 dcj3sjt126com apache
      现在假定你有两个目录，一个存在于 /htdocs/a，另一个存在于 /htdocs/b 。 现在你想要在本地测试的时候访问 www.freeman.com 对应的目录是 /xampp/htdocs/freeman ,访问 www.duchengjiu.com 对应的目录是 /htdocs/duchengjiu。 1、首先修改C盘WINDOWS\system32\drivers\etc目录下的
    • yii2 restful web服务[速率限制] dcj3sjt126com PHPyii2
      速率限制 为防止滥用，你应该考虑增加速率限制到您的API。 例如，您可以限制每个用户的API的使用是在10分钟内最多100次的API调用。 如果一个用户同一个时间段内太多的请求被接收， 将返回响应状态代码 429 (这意味着过多的请求)。 要启用速率限制, [[yii\web\User::identityClass|user identity class]] 应该实现 [[yii\filter
    • Hadoop2.5.2安装——单机模式 eksliang hadoophadoop单机部署
      转载请出自出处：http://eksliang.iteye.com/blog/2185414 一、概述        Hadoop有三种模式 单机模式、伪分布模式和完全分布模式，这里先简单介绍单机模式 ，默认情况下，Hadoop被配置成一个非分布式模式，独立运行JAVA进程，适合开始做调试工作。   二、下载地址 Hadoop 网址http:
    • LoadMoreListView+SwipeRefreshLayout（分页下拉）基本结构 gundumw100 android
      一切为了快速迭代 import java.util.ArrayList; import org.json.JSONObject; import android.animation.ObjectAnimator; import android.os.Bundle; import android.support.v4.widget.SwipeRefreshLayo
    • 三道简单的前端HTML/CSS题目 ini htmlWeb前端css题目
      使用CSS为多个网页进行相同风格的布局和外观设置时，为了方便对这些网页进行修改，最好使用（ ）。http://hovertree.com/shortanswer/bjae/7bd72acca3206862.htm   在HTML中加入<table style=”color:red; font-size:10pt”>，此为（ ）。http://hovertree.com/s
    • overrided方法编译错误 kane_xie override
      问题描述： 在实现类中的某一或某几个Override方法发生编译错误如下： Name clash: The method put(String) of type XXXServiceImpl has the same erasure as put(String) of type XXXService but does not override it   当去掉@Over
    • Java中使用代理IP获取网址内容（防IP被封，做数据爬虫） mcj8089 免费代理IP代理IP数据爬虫JAVA设置代理IP爬虫封IP
      推荐两个代理IP网站：   1. 全网代理IP：http://proxy.goubanjia.com/   2. 敲代码免费IP：http://ip.qiaodm.com/   Java语言有两种方式使用代理IP访问网址并获取内容，   方式一，设置System系统属性   // 设置代理IP System.getProper
    • Nodejs Express 报错之 listen EADDRINUSE qiaolevip 每天进步一点点学习永无止境nodejs纵观千象
      当你启动 nodejs服务报错： >node app Express server listening on port 80 events.js:85 throw er; // Unhandled 'error' event ^ Error: listen EADDRINUSE at exports._errnoException (
    • C++中三种new的用法 _荆棘鸟_ C++new
      转载自：http://news.ccidnet.com/art/32855/20100713/2114025_1.html 作者: mt 其一是new operator，也叫new表达式；其二是operator new，也叫new操作符。这两个英文名称起的也太绝了，很容易搞混，那就记中文名称吧。new表达式比较常见，也最常用，例如： string* ps = new string("
    • Ruby深入研究笔记1 wudixiaotie Ruby
      module是可以定义private方法的 module MTest def aaa puts "aaa" private_method end private def private_method puts "this is private_method" end end