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

【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,服务器,网络)

    • 《昼颜》里的日本女人：相遇要万种风情，分手要残忍绝情 迷影咖啡
      作者：迷之菌子神奇菇迷影咖啡：一本正经做烘焙，胡说八道聊电影漫天萤火虫消散之时良宵就将过去，人们也说含苞待放的花蕾总会开了又谢，因紧紧相拥而面红耳赤的躯体，便是我们经历过这热爱的证明。夫妻关系介绍《昼颜》是2014年电视剧《昼颜：工作日下午三点的恋人们》的续集，故事发在电视剧情节结束的三年后，讲述了已经恢复独身的纱和偶然与曾经的出轨对象北野重逢后再次陷入感情漩涡的故事。《昼颜》制作灵感源自利佳子在
    • 迎接2019 唯有杜康1994
      告别2018这一年是机遇与挑战，痛苦与喜悦，失去与收获的一年一月:收获了第一份爱情，开始真正想去了解一个人三月:对工作有了更深入的认识，靠自己的力量完成晋升五月:搬家，住进了自己理想的公寓，一间属于自己的屋子。满地的书六月:外调广州，升经理，有了自己的第一个团队。七月:怀着自我否定，第一次完成了部门任务八月:第一个员工流失，痛哭不已明白无不散之筵席九月:员工陆续离开，经济是一切的根本。十月:陪员工
    • 极狐GitLab 论坛 2.0 全新上线，可以在论坛上查找与 GitLab 相关的问题了～ 极小狐 gitlab极狐GitLabdevopsGitLabci/cddevsecopsSCM
      安装出现依赖错误？版本升级搞不定？遇到422、500就懵逼了？不知道某个功能是免费or付费？……使用GitLab这种全球顶级的DevOps平台进行软件研发时，总会遇到一些困惑，想跟专业的技术人员快速交流以便获得答案，同时又想把这些问题沉淀下来以帮助他人？有这种赠人玫瑰，手有余香的解决方案吗？答案肯定有：论坛！！！论坛——一个各路大神聚集的地方，一个可以解惑答疑问道的地方。解惑：搜索与自己问题相同或
    • 我喝醉了，但是与你无关 Z先生的日记本
      2019年04月10号晚上我和一个朋友喝酒了，彻彻底底的喝醉了，喝到短片，事后我问L，我说我喝醉了之后，都发生了什么，L没有告诉我详情，但是跟我说了大致，他说我跟他一直聊天，说自己小的时候的事，说自己爸妈的事，说自己现在过得很苦可能，确实是喝醉了酒，才会毫无防备的跟其他人说这些吧。L还说感觉我过得很苦，很心疼。醉了酒之后还哭了，想想还真是丢人一年前，在宿舍也有一瓶红酒，那是舍友出去拉赞助时候，友商
    • python抓包与解包_Python—网络抓包与解包（pcap、dpkt） weixin_39691055 python抓包与解包
      pcap安装[root@localhost~]#pipinstallpypcap抓包与解包#-*-coding:utf-8-*-importpcap,dpktimportre,threading,requests__black_ip=['103.224.249.123','203.66.1.212']#抓包：param1eth_name网卡名，如：eth0,eth3。param2p_type日志捕
    • 2022年河南省高等职业教育技能大赛云计算赛项竞赛赛卷（样卷） 忘川_ydy 云计算云计算openstackkubernetesdockerpythonk8sansible
      #需要资源（软件包及镜像）或有问题的，可私博主！！！#需要资源（软件包及镜像）或有问题的，可私博主！！！#需要资源（软件包及镜像）或有问题的，可私博主！！！第一部分：私有云任务1私有云服务搭建(10分)使用提供的用户名密码，登录竞赛用的云计算平台，按要求自行使用镜像创建两台云主机，创建完云主机后确保网络正常通信，然后按要求配置服务器。根据提供安装脚本框架，补充脚本完成OpenStack平台的安装搭
    • 浪潮 M5系列服务器IPMI无法监控存储RAID卡问题. Songxwn 硬件服务器服务器运维
      简介浪潮的M5代服务器，可能有WebBMC无法查看存储RAID/SAS卡状态的情况，可以通过以下方式修改。修改完成后重启BMC即可生效。ESXiIPMITools使用：https://songxwn.com/ESXi8_IPMI/（Linux也可以直接使用）Linux/ESXiIPMITool下载：https://songxwn.com/file/ipmitoolWindows下载：https:/
    • 拼多多纸巾推荐：品质与性价比的完美结合 氧惠帮朋友一起省
      拼多多纸巾推荐拼多多纸巾返现怎么做在我们的日常生活中，纸巾已经成为不可或缺的用品。无论是在家庭、办公室还是旅途中，纸巾都是我们随时随地需要的物品。随着电商平台的兴起，越来越多的人选择在网上购买纸巾。其中，拼多多作为国内知名的电商平台之一，以其独特的社交电商模式和实惠的价格吸引了大量用户。今天，我们就来探讨如何在拼多多上选择品质优良、性价比高的纸巾，以及如何通过一些小技巧来获取更多的优惠。一、品质与
    • word字号和mathtype磅值关系及批量修改 小铁匠-Ma office小技巧经验分享
      word字号和mathtype磅值关系及批量修改1.字号与磅值关系字号「八号」对应磅值5字号「七号」对应磅值5.5字号「小六」对应磅值6.5字号「六号」对应磅值7.5字号「小五」对应磅值9字号「五号」对应磅值10.5字号「小四」对应磅值12字号「四号」对应磅值14字号「小三」对应磅值15字号「三号」对应磅值16字号「小二」对应磅值18字号「二号」对应磅值22字号「小一」对应磅值24字号「一号」对应
    • 美团自动配送车2024春季招聘 | 社招专场 美团技术团队
      关于美团自动配送团队美团自动配送以自研L4级自动驾驶软硬件技术为核心，与美团即时零售业务结合，形成满足公开道路、校园、社区、工业园区等室外全场景下的自动配送整体解决方案。美团自动配送团队成立于2016年，团队成员来自于Waymo、Cruise、Pony.ai、泛亚等自动驾驶行业头部公司，自动驾驶技术团队博士占比高达30%，依靠视觉、激光等传感器，实时感知预测周围环境，通过高精地图定位和智能决策规划
    • 华为OD机试 - 单向链表中间节点（Java & JS & Python & C & C++） 华为OD题库 华为od链表java
      须知哈喽，本题库完全免费，收费是为了防止被爬，大家订阅专栏后可以私信联系退款。感谢支持文章目录须知题目描述输出描述解析代码题目描述给定一个单链表L，请编写程序输出L中间结点保存的数据。如果有两个中间结点，则输出第二个中间结点保存的数据。例如：给定L为1→7→5，则输出应该为7；给定L为1→2→3→4，则输出应该为3；输入描述每个输入包含1个测试用例。每个测试用例：第一行给出链表首结点的地址、结点总
    • php 把一个数组分成有n个元素的二维数组的算法 风清扬-独孤九剑 phpphp算法
      一、第一种解法0){$columns_map[$position]++;//这个地方格外注意,$position与$columns比较$position=($position<$columns-1)?++$position:0;$array_length--;}foreach($columns_mapas$val){$newarray[]=array_splice($array,0,$val);}
    • 学习JavaEE的日子 Day32 线程池 A 北枝 学习JavaEE学习java-eejava线程池
      Day32线程池1.引入一个线程完成一项任务所需时间为：创建线程时间-Time1线程中执行任务的时间-Time2销毁线程时间-Time32.为什么需要线程池(重要)线程池技术正是关注如何缩短或调整Time1和Time3的时间，从而提高程序的性能。项目中可以把Time1，T3分别安排在项目的启动和结束的时间段或者一些空闲的时间段线程池不仅调整Time1，Time3产生的时间段，而且它还显著减少了创建
    • 花气袭人知昼暖 柒侠传
      花气袭人知昼暖高一七班黄韵熹37号花袭人，原名花珍珠，位列金陵十二钗又副册中的第二位。“袭人”这一称呼源于“花气袭人知昼暖”这一诗句，是宝玉给起的。想起来便觉得暖融融的，一如花袭人温柔的笑容。但花袭人着实是令人又爱又怕的角色。第二十一回的回目将她赞作“贤袭人”，脂砚斋在一旁批道“当得起”。花袭人对宝玉的确是一片真心。她为劝宝玉收敛他那成日在大观园里与姐姐妹妹“厮混”的性子，假借家人赎回的机会，软语
    • 你之所以胖，可能是因为小时候发生这件事！还不赶快甩锅 周围_5d19
      通常，我们认为，“肥胖”主要是由于饮食不节制、不经常运动等等因素引起的。但最近，我国学者开展的一项针对6到18岁儿童青少年、随访长达十年的代谢综合征研究结果，在权威国际期刊发表。研究发现，儿童的肥胖和超重与睡眠密切相关，儿童、青少年时期睡眠不好，成人后也更容易患心血管疾病。那么，为什么儿童青少年睡眠不足会导致肥胖呢？今天就带大家一探究竟。儿童青少年肥胖的现状如何？近日，一项刊载在医学权威期刊《柳叶
    • uni-app实现 步骤条 夏夏的码农 uni-app
      实现如图样式html部分代码如下投资期限与收益0?'active':'default'">募集开始1?'active':'default'">募集结束2?'active':'default'">产品成立3?'active':'default'">产品到期0?'active-step1':'step1'">1?'active-st
    • 【算法分析与设计】去除重复字母 五敷有你 算法分析与设计javajavascript开发语言算法数据结构
      个人主页：五敷有你系列专栏：算法分析与设计⛺️稳中求进，晒太阳题目给你一个字符串s，请你去除字符串中重复的字母，使得每个字母只出现一次。需保证返回结果的字典序最小（要求不能打乱其他字符的相对位置）。示例示例1：输入：s="bcabc"输出："abc"示例2：输入：s="cbacdcbc"输出："acdb"思路贪心+单调栈实现【字符串删除一个字符使其字典序最小的贪心策略】：对于两个长度相同的字符串，
    • 购物返利平台是真的吗 返金app平台高佣返利省钱
      购物返利平台是真实存在的，它们提供一种通过购物来获取一定比例返现的服务。这些平台通常与商家合作，通过返利链接或其他追踪方式来追踪用户的购物行为，然后将一部分返现金额返还给用户。然而，需要注意的是，并非所有的购物返利平台都是可信的。在选择使用购物返利平台时，建议您注意以下几个方面：可信度和口碑：查看平台的用户评价和口碑，了解其他用户对该平台的使用体验和返利情况。合作商家：了解平台的合作商家是否可靠，
    • 【计算机网络】第 3 问：电路交换、报文交换、分组交换之间的区别？ 孤独打铁匠Julian #计算机408考研面试计算机网络计算机网络网络
      电路交换、报文交换、分组交换之间的区别？省流图详解电路交换电路交换的优点电路交换的缺点建立连接时间长的原因报文交换报文交换的优点报文交换的缺点分组交换分组交换的优点分组交换的缺点比较总结省流图详解电路交换在进行数据传输前，两个结点之间必须先建立一条专用（双方独占）的物理通信路径（由通信双方之间的交换设备和链路逐段连接而成），该路径可能经过许多中间结点。这一路径在整个数据传输期间一直被独占，直到通信
    • ＜商务世界＞《第25课 餐桌上的礼仪-简单的流程》 Ealser 商务世界中国餐桌礼节
      第一：迎客席座一般的程序是主人给客人邀请函——日子到了，主人到门外迎客——客人到了，问候几句——带着可人到0客厅小坐一会儿，给客人茶点——带客人入席坐好！第二：入座与座次首先要请客人中长者或地位高的先入座，再按身份地位依次入座，入座时要从椅子左边进入。（正对门口的为上座，一般是根据对方的.身份地位来安排）。入座后不要动筷子，更不要弄出什么响声来，也不要起身走动。如果有什么事要向主人打招呼！（做小辈
    • 【美丽特色乡村】，景德镇马鞍岭村， 粒子飞翔
      【美丽特色乡村】，景德镇马鞍岭村，就像是陶渊明笔下的山水田园，阡陌交通，精美的白房参差错落，碧绿透亮的河水从不远处的深涧里连绵不绝流入此地，滋养着土里。成群的白鸭悠闲地在河水里戏水，人与环境达成和谐的境界。借助三宝国际瓷谷建设的契机，马鞍岭村迎来了天翻地覆的沧桑巨变,此地以陶瓷文化为特色，融合原来生态资源，修复了水碓遗址、矿坑遗址等历史文化遗产，提升生态环境现状。同时，依托三宝溪围绕整个村落，对河
    • 2019.11.28感恩日记 afab5b74f713
      1.感谢真我守护，一觉到天明，谢谢谢谢谢谢！2.感谢一大早，橘子就甩来4800的大红包，谢谢谢谢谢谢！3.感谢今天代理宝宝们疯狂加单，钱宝宝流入小十万，太牛了你们，有你们真好，谢谢谢谢谢谢！4.感谢自己拥有钱宝宝，可以去群里给宝宝们发红包，表达我的爱，谢谢谢谢谢谢钱宝宝爱我！5.感谢自己的细胞宝宝们，让我保持健康与活力，可以自由活动，活力满满，谢谢谢谢谢谢！6.感谢芬姐甩来订单，谢谢谢谢谢谢钱宝宝
    • 请简单介绍一下Shiro框架是什么？Shiro在Java安全领域的主要作用是什么？Shiro主要提供了哪些安全功能？ AaronWang94 shirojavajava安全开发语言
      请简单介绍一下Shiro框架是什么？Shiro框架是一个强大且灵活的开源安全框架，为Java应用程序提供了全面的安全解决方案。它主要用于身份验证、授权、加密和会话管理等功能，可以轻松地集成到任何JavaWeb应用程序中，并提供了易于理解和使用的API，使开发人员能够快速实现安全特性。Shiro的核心组件包括Subject、SecurityManager和Realms。Subject代表了当前与应用
    • 子非鱼，焉知鱼之乐 零启若
      在如今网络爆飞信息发达的时代，我们会在各种论坛以及平台看到不计其数的评论，有一些人在评论的时候总是以高尚的道德为标准和底线去衡量，评判，甚至谩骂他人。并且觉得自己充满正义感，义正辞严。这些人姑且不说有没有考虑到别人的感受，更没有感同身受的体验，只是凭借着言论自由，甚至是一种猥琐和变相的心理发泄。就像人和动物一样，人类总是以高等动物自居，高高在上，并且认为人类吃食各种动物都是理所当然，动物就是给人吃
    • 谷歌浏览器驱动Chromedriver（114-120版本）文件以及驱动下载教程 pigerr杨 Pythonpythonchromedrivers
      ChromeDriver官方网站GitHub||GoogleChromeLabs/chrome-for-testingChromeDriver113-125_JSONChromeforTestingavailability123-125zip白月黑羽Python基础|进阶|Qt图形界面|Django|自动化测试|性能测试|JS语言|JS前端|原理与安装
    • 通俗易懂：什么是Java虚拟机（JVM）？它的主要作用是什么？ 大龄下岗程序员 mysqljavamysqlspring
      Java虚拟机（JavaVirtualMachine,JVM）是一种软件实现的抽象计算机，它负责执行Java字节码（Bytecode）。Java程序并不是直接在物理计算机上运行，而是先由Java编译器将源代码编译成与平台无关的字节码，然后由JVM负责读取字节码并在实际硬件架构上运行。JVM的主要作用包括以下几个方面：1.跨平台性-JVM是Java语言“一次编写，到处运行”（WriteOnce,Ru
    • 虚拟 DOM 的优缺点有哪些 咕噜签名分发 前端javascript开发语言
      虚拟DOM（VirtualDOM）技术作为现代前端开发中的重要组成部分，已经成为了众多流行前端框架的核心特性。它的引入为前端开发带来了诸多优势，同时也需要我们认真思考其潜在的考量。下面简单的介绍一下虚拟DOM技术的优势与缺点，深入探讨其在实际应用中的影响。提升性能虚拟DOM的最大优势之一是提升页面性能。通过比较前后两次虚拟DOM树的差异，最小化实际DOM操作，从而减少页面重渲染时的性能消耗。这种优
    • 大创项目推荐 深度学习 opencv python 公式识别(图像识别 机器视觉) laafeer python
      文章目录0前言1课题说明2效果展示3具体实现4关键代码实现5算法综合效果6最后0前言优质竞赛项目系列，今天要分享的是基于深度学习的数学公式识别算法实现该项目较为新颖，适合作为竞赛课题方向，学长非常推荐！学长这里给一个题目综合评分(每项满分5分)难度系数：3分工作量：4分创新点：4分更多资料,项目分享：https://gitee.com/dancheng-senior/postgraduate1课题
    • 关于举办第十五届蓝桥杯全国软件和信息技术专业人才大赛项目实战赛的通知 QSNKJJSW 蓝桥杯职场和发展青少年编程无人机机器人科技人工智能
      各高等院校及相关单位：为贯彻落实《中国教育现代化2035》和《国务院关于印发新时期促进集成电路产业和软件产业高质量发展若干政策的通知》有关精神，为我国制造强国和网络强国战略提供人才支持，提高学生自主创新意识和工程实践能力，工业和信息化部人才交流中心决定举办第十五届蓝桥杯全国软件和信息技术专业人才大赛——项目实战赛。大赛连续四年入围中国高等教育学会“全国普通高校大学生竞赛排行榜”竞赛项目榜单。现将项
    • 3、JavaWeb-Ajax/Axios-前端工程化-Element 所谓远行Misnearch #JavaWeb前端ajaxelementuijava前端框架
      P34Ajax介绍Ajax:AsynchroousJavaScriptAndXML，异步的JS和XMLJS网页动作，XML一种标记语言，存储数据，作用：数据交换：通过Ajax给服务器发送请求，并获取服务器响应的数据异步交互：在不重新加载整个页面的情况下，与服务器交换数据并实现更新部分网页的技术，例如：搜索联想、用户名是否可用的校验等等。同步与异步：同步：服务器在处理中客户端要处于等待状态，输入域名
    • 关于旗正规则引擎中的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