Netty权威指南（一）传统BIO模型、伪异步I/O模型

于 2021-02-22 16:58:03 发布
阅读量280 收藏 1
点赞数 1
分类专栏： Netty 面试 文章标签： 网络 socket java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DreamsArchitects/article/details/113933992
版权
面试 同时被 2 个专栏收录
15 篇文章 0 订阅
订阅专栏
Netty
10 篇文章 4 订阅
订阅专栏

文章目录

一、传统的BIO编程

网络编程的基本模型是Clinet/Server模型，也就是两个进程之间进行相互通信，其中服务端提供位置信息（绑定的IP地址和监听端口），客户端通过连接操作向服务端监听的地址发起连接请求，通过三次握手建立连接，如果连接建立成功，双方就可以通过网络套接字（Socket）进行通信。

在基于传统同步阻塞模型开发中，ServerSocket负责绑定IP地址，启动监听端口，Socket负责发起连接操作，连接成功之后，双方通过输入流和输出流进行同步阻塞式通信。

下面，我们就以经典的时间服务器（TimeServer）为例，通过代码分析来回顾和熟悉BIO编程。

采用BIO通信模型的服务端，通常由一个独立的Acceptor（接收器）线程负责监听客户端的连接，它接收到客户端连接请求之后为每一个客户端创建一个新的线程进行链路处理，处理完成之后，通过输出流返回应答给客户端，线程销毁，这就是经典的一请求一应答通信模型。

1.1TimeServer

package com.lsh.bio;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @author ：LiuShihao
 * @date ：Created in 2021/2/22 1:46 下午
 * @desc ： Netty权威指南
 *
 * 同步阻塞式I/O创建的TimeServer源码
 */
public class TimeServer {

    public static void main(String[] args) throws IOException {
        int port = 8888;
        ServerSocket server = null;
        try{
            server = new ServerSocket(port);
            System.out.println("The time server is start in port:"+port);
            Socket socket = null;
            while (true){
                socket = server.accept();
                new Thread(new TimeServerHandler(socket)).start();
            }

        } finally {
            if (server != null){
                System.out.println("The time server close");
                server.close();
                server = null;
            }
        }

    }
}

1.2 TimeServerHandler

package com.lsh.bio;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Date;

/**
 * @author ：LiuShihao
 * @date ：Created in 2021/2/22 2:00 下午
 * @desc ：同步阻塞I/O的TimeServerHandler
 * 当有新的客户端接入的时候，以Socket为参数构造TimeServerhandler对象，TimerServerHandler是一个Runnable，
 * 使用它为构造函数的参数创建一个新的客户端线程来处理这条Socket链路。
 *
 */
public class TimeServerHandler implements Runnable {
    private Socket socket;
    //有参构造
    public TimeServerHandler(Socket socket){
        this.socket = socket;
    }

    @Override
    public void run() {
        BufferedReader in = null;
        PrintWriter out = null;
        try{
            in = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
            out = new PrintWriter(this.socket.getOutputStream(),true);
            String currentTime = null;
            String body = null;
            /**
             * 通过BufferReader读取一行，如果已经读到了输入流的尾部，则返回值为null，退出循环，
             * 如果读到非空值，则对内容进行判断，
             * 如果请求消息为查询时间的指令"QUERY TIME ORDER" ，则获取当前系统最新的系统时间，通过PrintWriter的println的方法发送给客户端
             * 最后退出循环
             * 释放输入流、输出流和Socket套接字句柄资源
             */
            while (true){
                body = in.readLine();
                if (body == null){
                    break;
                }
                System.out.println("The time server receive order :"+body);
                currentTime = "QUERY TIME ORDER".equalsIgnoreCase(body) ? new Date(System.currentTimeMillis()).toString() :"BAD ORDER";
                out.println(currentTime);
            }

        }catch (Exception e){
            if (in != null){
                try {
                    in.close();

                }catch (IOException e1){
                    e1.printStackTrace();
                }
            }
            if (out != null){
                out.close();
                out = null;
            }
            if (this.socket != null){
                try {
                    socket.close();
                }catch (IOException e1){
                    e1.printStackTrace();
                }
                this.socket = null;

            }

        }


    }


}

1.3 TimeClient

package com.lsh.bio;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

/**
 * @author ：LiuShihao
 * @date ：Created in 2021/2/22 4:20 下午
 * @desc ：同步阻塞式I/O创建的TimeClient源码
 *
 * 客户端通过socket创建，发送查询时间服务器的"QUERY TIME ORDER"指令，
 * 然后读取服务端的响应并将结果打印出来，随后关闭连接，释放资源，程序退出执行
 *
 */
public class TineClient {
    public static void main(String[] args) {
        int port = 8888;
        Socket socket = null;
        BufferedReader in = null;
        PrintWriter out = null;
        /**
         * 通过PrintWirter向服务器端发送"QUERY TIME ORDER"指令
         * 然后通过BufferReader的readLine读取响应并打印
         */
        try{
            socket = new Socket("127.0.0.1", port);
            in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            out = new PrintWriter(socket.getOutputStream(),true);
            out.println("QUERY TIME ORDER");
            System.out.println("Sned order 2 server succeed.");
            String resp = in.readLine();
            System.out.println("Now is "+resp);


        }catch (Exception e){
            //不需要处理
        }finally {
            if (out !=  null){
                out.close();
                out = null;
            }
            if (in != null){
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                in = null;

            }
            if (socket != null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                socket = null;
            }

        }

    }
}

1.4 演示

首先启动TimeServer，然后启动TimeClient。
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

  1. TimeServer启动后通过server.accept()方法等待客户端连接。
  2. TimeClient启动后通过IP地址和端口号连接TimeServer。
  3. TimeServer获得客户端连接后，创建一个新的线程进行通信。
  4. TimeClient通过PrintWriter输出"QUERY TIME ORDER"到服务器端
  5. TimeServer通过BufferReader读取输入流信息，返回时间信息在通过PrintWriter写出。
  6. TimeClient在通过BufferReader读取输入流输出。

1.5 BIO总结

BIO的主要问题在于每当有一个新的客户端请求接入时，服务端必须创建一个新的线程处理新接入的客户端链路，一个线程只能处理一个客户端连接。
当客户端并发访问量增加后，服务端的线程个数和客户端并发访问数呈1：1的正比关系，由于线程是Java虚拟机非常宝贵的系统资源，当线程数膨胀之后，系统的性能将急剧下降，随着并发访问量的继续增大，系统会发生线程堆栈溢出、创建新线程失败等问题，并最终导致进程宕机或者僵死，不能对外提供服务。

在高性能服务器应用领域，往往需要面对成千上万个客户端的并发连接，这种模型显然不能满足高性能、高并发连接的特点、

二、伪异步I/O编程

为了解决同步阻塞IO面临的一个链路需要一个线程处理的问题，后来有人对它进行了优化：
后端通过一个线程池来处理多个客户端的请求接入，形成客户端个数M：线程池最大线程数N的比例关系，其中M可以远大于N。通过线程池可以灵活地调配线程资源，设置线程的最大值，防止由于海量并发接入导致线程耗尽。

当有新的客户端接入时：将客户端的Socket封装成一个Task（java.lang.Runnable接口）投递到后端的线程池进行处理，JDK的线程池维护一个消息队列和N个活跃线程，对消息队列中的任务进行处理。由于线程池可以设置消息队列的大小和最大线程数，因此，它的资源占用是可控的，无论多少个客户端并发访问，都不会导致资源的耗尽和宕机。

2.1 对TimeServer代码进行改造

package com.lsh.bio;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @author ：LiuShihao
 * @date ：Created in 2021/2/22 1:46 下午
 * @desc ： Netty权威指南   伪异步IO编程
 * 伪异步IO编程TimeServer源码
 */
public class TimeServer2 {

    public static void main(String[] args) throws IOException {
        int port = 8888;
        ServerSocket server = null;
        try{
            server = new ServerSocket(port);
            System.out.println("The time server is start in port:"+port);
            Socket socket = null;
            //创建IO任务线程池
            TimeServerHandlerExecutePool singleExecutor =  new TimeServerHandlerExecutePool(50, 10000);
            while (true){
                socket = server.accept();
                singleExecutor.execute(new TimeServerHandler(socket));
            }

        } finally {
            if (server != null){
                System.out.println("The time server close");
                server.close();
                server = null;
            }
        }

    }
}

首先创建了一个时间服务器处理类的线程池，当接收到新的客户端连接时，将请求Socket封装成一个Task，然后调用线程池的execute方法执行，从而避免了每一请求接入都创建一个新的线程。

2.2 TimeServerHandlerExecutePool

package com.lsh.bio;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @author ：LiuShihao
 * @date ：Created in 2021/2/23 12:40 下午
 * @desc ：伪异步IO编程  创建一个IO任务线程池
 */
public class TimeServerHandlerExecutePool {

    private ExecutorService executor;
    //创建一个线程池
    public TimeServerHandlerExecutePool(int maxPollSize, int queueSize) {
        executor = new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors(),
                maxPollSize,120L, TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(queueSize));
    }
    //执行
    public void execute(Runnable task) {
        executor.execute(task);
    }
}

由于线程池和消息队列的创建都是有界的，因此无论客户端并发连接数多大，它都不会导致线程个数膨胀和内存溢出，相比于传统的一连接一线程模型，是一种改良。

2.3 TimeServerHandler

代码不变

2.4 TimeClient

代码不变，创建两个客户端：

package com.lsh.bio;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

/**
 * @author ：LiuShihao
 * @date ：Created in 2021/2/22 4:20 下午
 * @desc ：同步阻塞式I/O创建的TimeClient源码
 *
 * 客户端通过socket创建，发送查询时间服务器的"QUERY TIME ORDER"指令，
 * 然后读取服务端的响应并将结果打印出来，随后关闭连接，释放资源，程序退出执行
 *
 */
public class TineClient1 {
    public static void main(String[] args) {
        int port = 8888;
        Socket socket = null;
        BufferedReader in = null;
        PrintWriter out = null;
        /**
         * 通过PrintWirter向服务器端发送"QUERY TIME ORDER"指令
         * 然后通过BufferReader的readLine读取响应并打印
         */
        try{
            socket = new Socket("127.0.0.1", port);
            in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            out = new PrintWriter(socket.getOutputStream(),true);
            out.println("QUERY TIME ORDER");
            System.out.println("TineClient1 Sned order 2 server succeed.");
            String resp = in.readLine();
            System.out.println("Now is "+resp);


        }catch (Exception e){
            //不需要处理
        }finally {
            if (out !=  null){
                out.close();
                out = null;
            }
            if (in != null){
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                in = null;

            }
            if (socket != null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                socket = null;
            }

        }

    }
}


package com.lsh.bio;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

/**
 * @author ：LiuShihao
 * @date ：Created in 2021/2/22 4:20 下午
 * @desc ：同步阻塞式I/O创建的TimeClient源码
 *
 * 客户端通过socket创建，发送查询时间服务器的"QUERY TIME ORDER"指令，
 * 然后读取服务端的响应并将结果打印出来，随后关闭连接，释放资源，程序退出执行
 *
 */
public class TineClient2 {
    public static void main(String[] args) {
        int port = 8888;
        Socket socket = null;
        BufferedReader in = null;
        PrintWriter out = null;
        /**
         * 通过PrintWirter向服务器端发送"QUERY TIME ORDER"指令
         * 然后通过BufferReader的readLine读取响应并打印
         */
        try{
            socket = new Socket("127.0.0.1", port);
            in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            out = new PrintWriter(socket.getOutputStream(),true);
            out.println("QUERY TIME ORDER");
            System.out.println("TineClient2 Sned order 2 server succeed.");
            String resp = in.readLine();
            System.out.println("Now is "+resp);


        }catch (Exception e){
            //不需要处理
        }finally {
            if (out !=  null){
                out.close();
                out = null;
            }
            if (in != null){
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                in = null;

            }
            if (socket != null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                socket = null;
            }

        }

    }
}

2.5 伪异步I/O的弊端分析

伪异步I/O通信框架采用了线程池的实现，因此避免了为每个请求都创建一个独立线程造成线程资源耗尽问题。但是由于它底层的通信依然采用同步阻塞模型，因此无法从根本上解决问题。

要对伪异步I/O的弊端进行深入分析，首先我们看两个Java同步IO的API说明。

Java输入流InputStream：

在这里插入图片描述
当对Socket的输入流进行读取操作的时候，它会一直阻塞下去，直到发生如下三件事：

  1. 有数据可读；
  2. 可用数据已经读取完毕；
  3. 发生空指针或者I/O异常；
    这意味着当对方发送请求或者应答消息比较缓慢，或者网络传输较慢时，读取输入流一方的通信线程将被长时间的阻塞，如果对方需要60s才能将数据发送完成，读取一方的I/O线程也将会被同步阻塞60s，在此期间其他接入消息只能在消息队列中排队。

Java输入流OutputStream：
在这里插入图片描述

当调用OutputStream的write方法写输出流的时候，它将会被阻塞，直到所有要发送的字节全部写入完毕，或者发生异常。（学习过TCP/IP协议的应该知道，当消息的接受方处理缓慢的时候，将不能及时地从TPC缓冲区读取数据，这将会导致发送方的TCP window size不断减小（），直到为0。）双方处于Keep-alive状态，消息发送方将不能在向TCP缓冲区写入消息，这时如果采用的是同步阻塞I/O，write操作将会被无限期阻塞，直到TCP 的window sizw 大于0或者发生异常。
ps：TCP header中有一个Window Size字段，它其实是指接收端的窗口，即接收窗口，用来告知发送端自己所能接收的数据量，从而达到一部分流控的目的。

通过对输入和输出流的API文档的分析，我们了解到读和写的操作都是同步阻塞的，阻塞的时间取决于对方I/O线程的处理速度和网络I/O的传输速度。

伪异步I/O实际上仅仅只是对之前的I/O线程模型的一个简单优化，它无法从根本上解决同步I/O导致的通信线程阻塞问题。

Liu_Shihao
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Netty框架之异步事件驱动模型
09-15
Netty框架之异步事件驱动模型
Java NIO 基础
孙晴
07-29 269
Java 1.4 之前的版本，对I/O的支持不是很完善，在开发高性能的I/O程序时，主要面临以下问题。 1、没有数据缓冲区，I/O性能存在问题； 2、只有输入和输出流，没有C或者C++中的Channel概念； 3、同步阻塞式I/O通信（BIO），通常会导致通信线程被长时间阻塞； 4、支持的字符集有限，硬件可移植性不好。 下面对Java I/O的演进过程做一个简单梳理。 网络编程的基
netty权威指南学习笔记一——NIO入门（1）BIO
zuixiaoyao_001的博客
07-07 176
&#13; 　　公司的一些项目采用了netty框架，为了加速适应公司开发，本博主认真学习netty框架，前一段时间主要看了看书，发现编程这东西，不上手还是觉得差点什么，于是为了加深理解，深入学习，本博主还是决定多动手，一方面记录一些总结性的思考性东西，另一方面也为日后复习查看留下一些东西。 　　那么废话少说，现在开始，首先在进入netty学习之前，我们是要认识一下IO并引出N...
Netty之NIO入门（二）
FJJJJJ
07-23 1424
BIO 下图的通信模型图来熟悉下BIO的服务端通信模型：采用BIO通信模型的服务端，通常由一个独立的 Acceptor线程负责监听客户端的连接，它接收到客户端连接请求之后为每个客户端创建一个新的线程进行链路处理，处理完成之后，通过输出流返回应答给客户端，线程销毁。这就是典型的一请求一应答通信模型。 该模型最大的问题就是缺乏弹性伸缩能力，当客户端并发访问量增加后，服务端的线程个数和客户端并发访问数呈1:1的正比关系，由于线程是Java虚拟机非常宝贵的系统资源，当线程数膨胀之后，系统的性能将急剧下降，随着并发
关于《Netty权威指南》第三章中TimeServerHandler无法编译通过的解决方法
JAVA飘香
07-11 798
由于该书出版较早，当前Netty已经升级到了4.1.37，Netty对架构进行了较大的改进工作，因此书中的部分例子无法正常编译通过。该书第三章中TimeServer需要用到TimeServerHandler类，该类继承自ChannelHandlerAdapter，覆盖了channelRead、channelReadComplete两个父类方法。但在当前版本的Netty中，ChannelHandle...
【Netty权威指南读书笔记】BIO通信模型
Azeroth
09-10 95
 　　采用BIO通信模型的服务端，通常由一个独立的Acceptor线程负责监听客户端的连接，它接收到客户端连接请求之后为每个客户端创建一个新的线程进行链路处理，处理完成之后，通过输出流返回应答给客户端，线程销毁。Blocking-IO是典型的一请求一应答的模型。 　　该模型最大的问题就是缺乏弹性伸缩能力，当客户端并发访问量增加后，服务端的线程个数和客户端并发访问数量呈1：1的正比关系。由于线...
netty权威指南 第1版（李林峰） + 源码
09-12
《Netty权威指南》第1版 是异步非阻塞通信领域的经典之作，基于最新版本Netty 5.0编写，是国内首本深入介绍Netty原理和架构的技术书籍，也是作者多年实战经验的总结和浓缩。在理论方面，讲解了Netty的逻辑架构模型和...
netty高性能异步I/O服务器/客户端开源开发工具
01-30
netty高性能异步I/O服务器/客户端开源开发工具，支持多种transport protocol提供多种开发ChannelHandler实现类
netty权威指南 第2版（李林峰） + 源码
09-12
, 《Netty权威指南》适合架构师、设计师、软件开发工程师、测试人员和其他对Java NIO框架、Java通信感兴趣的相关人士阅读，相信通过学习《Netty权威指南》，能够熟悉和掌握Netty这一优秀的异步通信框架，实现高可用...
《Netty权威指南（第二版）》.pdf
07-19
Netty权威指南第二版PDF
Netty（7）-传对象
weixin_30883271的博客
10-30 81
改造timer，即客户端与服务端建立连接后，服务端主动向客户端发送当前时间。 server： ch.pipeline().addLast(new TimeEncoder()); ch.pipeline().addLast(new TimeServerHandler()); TimeServerHandler public class TimeServerHandler ...
BIO模型
禾露悠悠摇的博客
02-25 1180
BIO通信模型 传统的BIO模型（同步阻塞IO模型）+线程池（多线程）模式：适合活动连接次数不是特别高。该模式是1:1，即每次连接每个线程。 处理步骤：客户端发送请求，接收器Acceptor每接收一个请求，就创建一个新线程，处理完成之后，再通过输出流返回到客户端，然后销毁线程。 缺陷：一个客户端请求，就对应一个线程，客户端的请求和服务端的线程就成为1:1的比例，当请求过多的时候，线程越来越多...
netty入门——TimeServer和TimeClient
archer的技术故事
07-07 2258
主要参考：《netty权威指南》http://netty.io/wiki/user-guide-for-4.x.html当前没有处理tcp的拆包和粘包问题。先简单的介绍一下netty，netty是一个高性能的网通通信框架。以下摘自官网。The Netty project is an effort to provide an asynchronous event-driven network app...
Netty实现时间服务示例
博观约取
06-20 2663
相关知识点： [1] ChannelGroup是一个容纳打开的通道实例的线程安全的集合，方便我们统一施加操作。所以在使用的过程中可以将一些相关的Channel归类为一个有意义的集合，关闭的通道会自动从集合中移除，而且一个Channel可以属于多个ChannelGroup。常见的应用场景是 向一组通道广播消息；简化一组通道的关闭流程。 [2] 因为在Channel中流通的是Channel
Java 网络IO编程总结（BIO、NIO、AIO均含完整实例代码）
热门推荐
anxpp的博客
05-29 17万+
本文会从传统的BIO到NIO再到AIO自浅至深介绍，并附上完整的代码讲解。 1、BIO编程 1.1、传统的BIO编程 网络编程的基本模型是C/S模型，即两个进程间的通信。 服务端提供IP和监听端口，客户端通过连接操作想服务端监听的地址发起连接请求，通过三次握手连接，如果连接成功建立，双方就可以通过套接字进行通信。 传统的同步阻塞模型开发中，ServerSocket负责绑定IP地址，启动监听端口；Socket负责发起连接操作。连接成功后，双方通过输入和输出流进行同步阻塞式通信。
netty实现TimeServer服务
feng_0207的专栏
09-21 660
服务端代码： package com.my.test.netty; import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelInitializer; import io.netty.channel.ChannelOption;
使用netty的NIO来实现一个简单的TimeServer
weixin_33797791的博客
12-26 131
只想以此来加深java的NIO这方面的知识点~~~ 参考书籍《netty权威指南》(第二版) 这本书，第一二三章，前面讲java的bio,nio,nio2， 讲得蛮好的。 package com.phei.netty; import io.netty.bootstrap.ServerBootstrap; import io.netty.chann...
Netty入门之 TimeServer && TimeClient
qq_27061805的博客
06-09 387
1.TimeServer /** * Created by ju on 2017-06-09. */ public class TimeServer { public void bind(int port) { EventLoopGroup bossGroup = new NioEventLoopGroup(); EventLoopGroup worker
谈谈传统BIO网络编程模型的局限性与NIO
最后一个NPE
04-25 339
先来看看我们的server端： 创建一个serversocket，进行监听，每来一个客户端，就启动一个新启动为其服务： private void createListenSocket() { //如果创建监听socket的时候发生异常,将会隔WAIT_TIME毫秒重试，直到成功 while (true){ try { ...
netty权威指南第一版源码
最新发布
08-02
《Netty权威指南》第一版源码是指该书第一版中所涉及的示例代码和相关资源。该书主要介绍了Netty框架的基本原理、核心组件和常见应用场景等内容，通过示例代码演示了Netty的使用方法和技巧。 《Netty权威指南》第一版源码可以作为读者学习Netty的参考资料，通过阅读和运行源码，读者可以更深入地理解书中的概念和原理。源码中的示例代码包括了基于TCP和UDP协议的网络通信示例、HTTP和WebSocket协议的应用示例等，这些示例覆盖了Netty框架的各个方面。 在源码中，读者可以学习到如何构建和启动一个Netty应用程序，如何处理不同类型的数据，如何实现高性能的网络通信，如何处理并发和数据安全等问题。源码中还包括了一些常见的应用场景示例，如聊天室、文件传输、HTTP服务器等，读者可以通过运行这些示例代码来更好地理解和掌握Netty的使用方法。 需要注意的是，《Netty权威指南》第一版的源码可能与最新的Netty版本有所差异，读者在使用源码时需要根据自己实际的Netty版本进行相应的调整和适配。 总之，《Netty权威指南》第一版源码是一份宝贵的学习资源，通过阅读和运行源码，读者可以更加深入地学习和理解Netty框架的使用方法和技巧，提升自己在网络编程方面的能力。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Liu_Shihao

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值