Netty学习前置知识（一）

最新推荐文章于 2023-05-20 21:40:29 发布
最新推荐文章于 2023-05-20 21:40:29 发布
阅读量2.3k 收藏 5
点赞数 1
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013351117/article/details/121318138
版权

文章目录

前言

此篇博文主要根据尚硅谷的视频课程把使用Netty需要了解的知识进行整理并根据自己的理解加以补充。由于内容较多所以将笔记分为多个部分，同时更新速度可能会比较慢，希望读者多包涵。

Netty 介绍

  • Netty 是由 JBOSS提供的一个Java 开源框架，现为Github上的独立项目。
  • Netty是一个异步的，基于事件驱动的网络应用框架，用一快速开发高性能、高可靠的网络IO程序。
  • Netty 主要针对TCP协议下，面向Clients端高并发应用，或者Peer-to-Peer(简称P2P)场景下的大量数据持续传输的应用。
  • Netty 本质是一个NIO框架，使用与服务器通信相关的多种应用场景。

Netty 使用场景

互联网行业

  1. 在分布式系统中，各个节点之间需要远程服务调用，高性能的RPC框架必不可少，Netty作为异步高性能通信框架，往往作为基础通信组件被这些RPC框架使用。
  2. 典型的应用有：阿里分布式服务框架Dubbo的RPC框架，使用协议进行节点间通信，Dubbo协议默认使用Netty作为基础通信组件，用于实现各个进程节点之间的内部通信。

游戏行业

  1. 无论是手游服务端还是大型网络游戏Java语言得到了越来越广的应用。
  2. Netty作为高性能的基础通信组件，提供了TCP/UDP和HTTP协议栈，方便定制和开发私有协议栈，账号登陆服务器。
  3. 地图服务器之间可以方便的通过Netty进行高性能的通信。

大数据领域

  1. 经典的 Hadoop 的高性能通信和序列化组件 Avro 的 RPC 框架，默认采用 Netty 进行跨界点通信。
  2. 它的 NettyService 基于 Netty 框架二次封装实现。

Java IO模型

IO模型

  1. I/O模型的简单理解：就是用什么样的通道进行数据发送和接受，很大程度上决定了程序的通信性能。

  2. Java 支持3种网络编程模型：BIO/NIO/AIO

  3. Java BIO:同步且阻塞，服务器实现模式是一个连接一个线程，即客户端有连接请求是服务端就需要启一个线程来进行处理，如果这个连接一直不处理会造成不必要的线程开销。
    在这里插入图片描述

  4. Java Nio:同步非阻塞，服务器实现模式为一个线程处理多个连接请求，即客户端发送的连接请求会注册到多路复用器上，多路复用器轮询到连接有I/O请求进行处理。
    在这里插入图片描述

  5. Java AIO(NIO.2)：异步非阻塞，AIO 引入异步通道的概念，采用了 Proactor 模式，简化了程序编写，有效的请求才启动线程，它的特点是先由操作系统完成后才通知服务端程序启动线程去处理，一般适用于连接数较多且连接时间较长的应用。

BIO,NIO,AIO场景分析比较

  1. BIO 方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4 以前的唯一选择，但程序简单易理解。
  2. NIO 方式适用于 连接数目多且连接比较短（轻操作）的架构，比如聊天服务器，弹幕系统，服务器间通讯等。编程比较复杂，JDK1.4 开始支持。
  3. AIO 方式使用于连接数目多且连接比较长（重操作）的架构，比如相册服务器，充分调用 OS 参与并发操作，编程比较复杂，JDK7 开始支持。

Java BIO 编程

Java BIO介绍

  1. Java BIO 就是传统的 Java I/O 编程，其相关的类和接口在 java.io。
  2. BIO(BlockingI/O)：同步阻塞，服务器实现模式为一个连接一个线程， 即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，可以通过线程池机制改善（实现多个客户连接服务器）。
  3. BIO 方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4 以前的唯一选择，程序简单易理解。

Java BIO工作机制

在这里插入图片描述

BIO工作机制梳理

  1. 服务器端启动一个 ServerSocket。
  2. 客户端启动 Socket 对服务器进行通信，默认情况下服务器端需要对每个客户建立一个线程与之通讯。
  3. 客户端发出请求后，先咨询服务器是否有线程响应，如果没有则会等待，或者被拒绝。如果有响应，客户端线程会等待请求结束后，再继续执行。

Java BIO编程实例

@Slf4j
public class Server {
    public static void main(String[] args) throws IOException {
        ExecutorService executorService = new ThreadPoolExecutor(4,8,0L,TimeUnit.MILLISECONDS,new LinkedBlockingDeque<>());
        ServerSocket serverSocket = new ServerSocket(12345);
        log.info("服务启动了");
        while (true){
            Socket socket = serverSocket.accept();
            log.info("有客户端连接了");
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    byte[] bytes = new byte[1024];
                    try {
                        while (true){
                        InputStream inputStream = socket.getInputStream();
                        int read = inputStream.read(bytes);
                        if(read!=-1){
                            System.out.println(new String(bytes,0,read));
                        }else {
                            break;
                        }
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }finally {
                        System.out.println("服务端关闭");
                    }
                }
            });
        }
    }
}

客户端采用telnet：
在这里插入图片描述

问题分析

  1. 每个请求都需要创建独立的线程，与对应的客户端进行数据Read、Write。
  2. 当并发数较大时需要创建大量线程来处理连接，系统资源占用较大。
  3. 连接建立后，如果当前线程暂时没有数据可读，则线程阻塞在Read操作上，造成资源浪费。

Java NIO 编程

Java NIO介绍

  1. Java NIO 全称Java non-blocking IO，是指 JDK 提供的新 API。从 JDK1.4 开始，Java 提供了一系列改进的输入/输出的新特性，被统称为 NIO（即 NewIO），是同步非阻塞的。
  2. NIO 相关类都被放在 java.nio 包及子包下，并且对原 java.io 包中的很多类进行改写。
  3. NIO 有三大核心部分：Channel（通道）、Buffer（缓冲区）、Selector（选择器）。
  4. NIO 是面向缓冲区，或者面向块编程的。数据读取到一个它稍后处理的缓冲区，需要时可在缓冲区中前后移动，这就增加了处理过程中的灵活性，使用它可以提供非阻塞式的高伸缩性网络。
  5. Java NIO 的非阻塞模式，使一个线程从某通道发送请求或者读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取，而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。非阻塞写也是如此，一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。
  6. 通俗理解：NIO 是可以做到用一个线程来处理多个操作的。假设有 10000 个请求过来,根据实际情况，可以分配 50 或者 100 个线程来处理。不像之前的阻塞 IO 那样，非得分配 10000 个。
  7. HTTP 2.0使用了多路复用的技术，做到同一个连接并发处理多个请求，而且并发请求的数量比 HTTP 1.1 大了好几个数量级。

NIO 与 BIO比较

  1. BIO以流的方式处理数据，而 NIO以块的方式处理数据，块 I/O 的效率比流 I/O 高很多。
  2. BIO是阻塞的，NIO则是非阻塞的。
  3. BIO基于字节流和字符流进行操作，而 NIO基于 Channel（通道）和 Buffer（缓冲区）进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。```Selector````（选择器）用于监听多个通道的事件（比如：连接请求，数据到达等），因此使用单个线程就可以监听多个客户端通道。
  4. Buffer和Channel之间的数据流向是双向的
    在这里插入图片描述

NIO三大核心原理图

NIO 的 Selector、Channel 和、Buffer 之间关系

在这里插入图片描述

三大核心关系解读

1. 每个 Channel 都会对应一个 Buffer。
2. Selector 对应一个线程，一个线程对应多个 Channel（连接）。
3. 该图反应了有三个 Channel 注册到该 Selector //程序
4. 程序切换到哪个 Channel 是由事件决定的，Event 就是一个重要的概念。
5. Selector 会根据不同的事件，在各个通道上切换。
6. Buffer 就是一个内存块，底层是有一个数组。
7. 数据的读取写入是通过 Buffer，这个和 BIO是不同的，BIO 中要么是输入流，或者是输出流，不能双向，但是 NIO 的 Buffer 是可以读也可以写，需要 flip 方法切换 Channel 是双向的，可以返回底层操作系统的情况，比如 Linux，底层的操作系统通道就是双向的。

缓冲区Buffer

基本介绍

缓冲区（Buffer）：
  缓冲区本质上是一个可以读写数据的内存块，Jdk1.8里面是这么说的A container for data of a specific primitive type也可以理解成是一个容器对象（含数组），该对象提供了一组方法，可以更轻松地使用内存块，，缓冲区对象内置了一些机制，能够跟踪和记录缓冲区的状态变化情况。Channel 提供从文件、网络读取数据的渠道，但是读取或写入的数据都必须经由 Buffer。
在这里插入图片描述

Buffer及其子类

1.在 NIO 中，Buffer 是一个顶层父类，它是一个抽象类，类的层级关系图：
在这里插入图片描述

2.Buffer 类定义了所有的缓冲区都具有的四个属性来提供关于其所包含的数据元素的信息：
在这里插入图片描述

基本属性： capacity, limit, and position

  初始化元素状态：新建的buffer的position始终是0，mark是未被标记，limit是0也可以是其他值这依赖于buffer的类型和使用方式

A newly-created buffer always has a position of zero and a mark that is
undefined.  The initial limit may be zero, or it may be some other value
that depends upon the type of the buffer and the manner in which it is
constructed.  Each element of a newly-allocated buffer is initialized
to zero.

Clearing, flipping, and rewinding

除了访问position, limit, capacity，mark，reset之外，此buffer类也定义了如下操作：
clear():为一个新的通道读取序列或相对于put操作准备好缓冲区：limit,capacity,position都设为0
flip():为一个新的通道写入序列或相对于get操作准备好缓冲区：此时limit设置为当前的position，position设置为0
rewind():为重复读取它已经包含的数据准备一个缓冲区。此时limit不变，position设置为0

线程安全（Thread safety）

  1. 当多线程访问时缓冲区不是线程安全，如果要使用多线程访问缓冲区则适当使用同步控制
  2. 允许链式调用：b.flip().position(23).limit(42);

Channel（通道）

channel基本介绍

  • NIO 的通道类似于流，但有些区别如下：
    • 通道可以同时进行读写，而流只能读或者只能写
    • 通道可以实现异步读写数据
    • 通道可以从缓冲读数据，也可以写数据到缓冲:
  • BIO 中的 Stream 是单向的，例如 FileInputStream 对象只能进行读取数据的操作，而 NIO 中的通道（Channel）是双向的，可以读操作，也可以写操作。
  • Channel 在 NIO 中是一个接口 public interface Channel extends Closeable{}
    常用的 Channel 类有：FileChannel、DatagramChannel、ServerSocketChannel 和 SocketChannel。【ServerSocketChanne 类似 ServerSocket、SocketChannel 类似 Socket】
  • FileChannel 用于文件的数据读写，DatagramChannel 用于 UDP 的数据读写，ServerSocketChannel 和 SocketChannel 用于 TCP 的数据读写。

FileChannel 类

FileChannel 主要用来对本地文件进行 IO 操作，常见的方法有：
public int read(ByteBuffer dst)，从通道读取数据并放到缓冲区中
public int write(ByteBuffer src)，把缓冲区的数据写到通道中
public long transferFrom(ReadableByteChannel src, long position, long count)，从目标通道中复制数据到当前通道
public long transferTo(long position, long count, WritableByteChannel target)，把数据从当前通道复制给目标通道

FileChannel 向本地文件写入数据：实例一

/**
 * @ClassName: FIleServer
 * @Description: 使用NIO向文件写数据：将数据写入filechannel.txt文件中
 * @Author: admin
 */
public class FIleServer {
    public static void main(String[] args) {
        try {
            // 创建文本
            FileOutputStream fileOutputStream = new FileOutputStream("d:\\filechannel.txt");
            // 获取channel
            FileChannel fileChannel = fileOutputStream.getChannel();
            // 创建一个缓存区
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
            // 将数据写入buffer
            byteBuffer.put("FileChannel 用于文件的数据读写，DatagramChannel 用于 UDP 的数据读写，ServerSocketChannel 和 SocketChannel 用于 TCP 的数据读写。".getBytes());
            // 反转
            byteBuffer.flip();
            // 将数据写入channel中
            fileChannel.write(byteBuffer);
            // 关闭channel
            fileOutputStream.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

FileChannel 向本地文件写入数据：实例二

/**
 * @ClassName: FileInputServer
 * @Description: 通过channel读取d:\filechannel.txt中的数据并输出
 * @Author: admin
 */
public class FileInputServer {
    public static void main(String[] args) {
        String pathname = "d:\\filechannel.txt";
        File file = new File(pathname);
        try {
            // 通过输入流获取数据
            FileInputStream fileInputStream = new FileInputStream(file);
            // 获得channel
            FileChannel fileChannel = fileInputStream.getChannel();
            // 创建buffer
            ByteBuffer byteBuffer = ByteBuffer.allocate((int) file.length());
            // 读取数据到buffer中
            fileChannel.read(byteBuffer);
            // 输出数据
            System.out.println(new String(byteBuffer.array()));
            // 关闭流
            fileInputStream.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

FileChannel 向本地文件写入数据：实例三

实例说明：
使用一个 Buffer 完成文件读取、写入 从filechannel.txt中读取数据。
将读取的数据写到file03.txt。
实例演示。

在这里插入图片描述

/**
 * @ClassName: FileChannel03
 * @Description: 从filechannel.txt中读取数据并写入file03.txt中
 * @Author: admin
 */
public class FileChannel03 {
    public static void main(String[] args) {
        try {
            // 从filechannel.txt读取数据
            String pathname = "d:\\filechannel.txt";
            File file = new File(pathname);
            FileInputStream fileInputStream = new FileInputStream(file);
            FileChannel channel1 = fileInputStream.getChannel();
            // 创建输出流写入数据到file03.txt中
            FileOutputStream fileOutputStream = new FileOutputStream("d:\\file03.txt");
            FileChannel channel2 = fileOutputStream.getChannel();
            ByteBuffer allocate = ByteBuffer.allocate((int)file.length());
            // 循环读取
            while(true){
                allocate.clear();
                int read = channel1.read(allocate);
                if(read==-1){
                  break;
                }
                // 写入数据到file03.txt中
                allocate.flip();
                channel2.write(allocate);
            }
            fileOutputStream.close();
            fileInputStream.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

FileChannel 向本地文件写入数据：实例四

使用 FileChannel（通道）和方法 transferFrom，完成文件的拷贝 实例演示

/**
 * @ClassName: FileChannel04
 * @Description: 使用transferFrom将图片从D:\images\buffer.jpg拷贝到d:\buffer.jpg
 * @Author: admin
 */
public class FileChannel04 {
    public static void main(String[] args) {
        try {
            // 从D:\images\buffer.jpg读取文件
            String pathname = "D:\\images\\buffer.jpg";
            File file = new File(pathname);
            FileInputStream fileInputStream = new FileInputStream(file);
            FileChannel channel1 = fileInputStream.getChannel();
            // 创建输出流写入数据到file03.txt中
            FileOutputStream fileOutputStream = new FileOutputStream("d:\\buffer.jpg");
            FileChannel channel2 = fileOutputStream.getChannel();
            channel2.transferFrom(channel1,0,channel1.size());
            fileOutputStream.close();
            fileInputStream.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
重点方法说明：
  • **transferFrom**是一个抽象方法，主要是将字节从给定的可读字节传输到此通道的文件中。
 public abstract long transferFrom(ReadableByteChannel src,long position, long count)throws IOException; ReadableByteChannel继承Channel,一个可读取字节的通道（A channel that can read bytes)。

 - <p> Only one read operation upon a readable channel may be in progress at
 - any given time.  If one thread initiates a read operation upon a channel
 - then any other thread that attempts to initiate another read operation will
 - block until the first operation is complete.  Whether or not other kinds of
 - I/O operations may proceed concurrently with a read operation depends upon
 - the type of the channel. </p>
  • 任何时间可读信道上只能进行一次读取操作。
  • 如果一个线程在通道上启动读操作，则尝试启动另一个读操作的任何其他线程将阻塞，直到第一个操作完成。
  • 其他类型的I / O操作是否可以与读操作同时进行取决于通道的类型。

Buffer 和 Channel的附加说明

  1. **Buffer**存数据和取数据类型要一致。
  2. Buffer可以转成**只读**Buffer。
  3. 可以使用**MappedByteBuffer**让文件直接在内存（堆外的内存）中进行修改，而如何同步到文件由 NIO 来完成。
  4. Nio支持多个**Buffer**来完成数据读写，即 Scattering 和 Gathering。见ServerSocketChannel实例演示
ServerSocketChannel 实例演示
/**
 * @ClassName: ScatteringAndGathering05
 * @Description:使用Buffer数组读写数据
 * @Author: admin
 */
public class ScatteringAndGathering05 {
    public static void main(String[] args) {
        try {
            ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
            // 设置地址
            InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 1234);
            ServerSocket socket = serverSocketChannel.socket();
            // 绑定端口
            socket.bind(inetSocketAddress);

            // 创建Buffer
            ByteBuffer[] byteBuffers = new ByteBuffer[2];
            byteBuffers[0] = ByteBuffer.allocate(5);
            byteBuffers[1] = ByteBuffer.allocate(3);

            // 等待连接
            SocketChannel accept = serverSocketChannel.accept();

            // 初始化消息长度
            int mesLength = 8;
            while (true){
                int readLen = 0;
                while (readLen < mesLength){
                    long read = accept.read(byteBuffers);
                    readLen += read;
                    System.out.println("readLen = " + readLen);
                    //使用流打印,看看当前的这个 buffer 的 position 和 limit
                    Arrays.asList(byteBuffers).stream().map(buffer -> "position = " + buffer.position() + ", limit = " + buffer.limit()).forEach(System.out::println);
                }
                // 反转数据
               Arrays.asList(byteBuffers).forEach(v->v.flip());
                //将数据读出显示到客户端
                long byteWirte = 0;
                while (byteWirte < mesLength) {
                    long l = accept.write(byteBuffers);
                    byteWirte += l;
                }

                //将所有的buffer进行clear
                Arrays.asList(byteBuffers).forEach(buffer -> {
                    buffer.clear();
                });
                System.out.println("readLen = " + readLen + ", byteWrite = " + byteWirte + ", mesLength = " + mesLength);
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在这里插入图片描述

小蚂蚁2021
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
从 BIO、NIO 到 Netty【前置知识点】
小牛肉的博客
12-21 400
详细讲解从 BIO、NIO 到 Netty 的发展史
什么是 RPC 及其原理【前置知识点】
小牛肉的博客
12-19 537
RPC（Remote Procedure Call）远程过程调用，它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。比如两个不同的服务 A、B 部署在两台不同的机器上，那么服务 A 如果想要调用服务 B 中的某个方法该怎么办呢？使用 HTTP 请求当然可以，但是可能会比较麻烦。 RPC 的出现就是为了让你调用远程方法像调用本地方法一样简单。
初识Netty-前置知识
qq_44641527的博客
03-13 161
netty
Netty学习前置知识：IO模型
仔哥学编程
01-17 562
Netty学习前置知识：IO模型
netty前置知识
xiaotai1234的博客
02-22 440
netty前置知识 一、BIO编程 二、NIO编程 1.概述 2.文件 IO 概述和核心API 案例 3.网络 IO 概述和核心API 入门案例 网络聊天案例 4. AIO编程 5. IO对比总结
Netty前置知识
12-21 377
Netty 前置知识、马士兵教育笔记
Netty源码解析系列一：Netty架构
最新发布
Running666的博客
05-20 1237
Netty源码分析系列1
「Netty系列」彻底弄清网络七层协议、TCP/IP、IP、TCP(Netty前置一)
flowerAndJava的博客
12-21 917
目前工作中使用Netty进行服务端开发，在实践中有自己一点点心得。接下来分享Netty系列文章。在学习Netty之前先了解下网络基础知识、分清网络七层协议、TCP/IP协议族、IP、TCP各代表什么含义。 一 基础 1.1 概述 1 网络分层中的IOS七层模型、TCP/IP协议族、TCP、IP，这些有什么不同 2 TCP协议通信过程中的三次握手和四次挥手到底是什么流程？ 1.2 软件架构 在生活中，我们经常用QQ、微信、百度云盘、Goole、IE浏览器、火狐浏览器......。可以总结为两大类，c
Netty学习之旅----源码分析内存分配与释放原理，java基础入门pdf百度云
m0_64383449的博客
12-03 164
PooledByteBuf buf = newByteBuf(maxCapacity); //@1 allocate(cache, buf, reqCapacity); //@2 return buf; } 1.2.1 PoolArena allocatede 代码@1：newByteBuf：先创建一个PooledByteBuf，这里有个亮点如下。 static PooledHeapByteBuf newInstance(int maxCapacity) { PooledHeapByteBuf buf =
Netty学习之旅----源码分析内存分配与释放原理，java基础面试集合
m0_63176399的博客
11-19 415
subpage = new PoolSubpage(this, id, runOffset(id), pageSize, normCapacity); // 代码@3 subpages[subpageIdx] = subpage; } else { //@4 subpage.init(normCapacity); } return subpage.allocate(); //代码@5 } 首先讲解一下整体分配思路，先根据PoolChunk内部维护的各个PoolChunk的占用情况，返回一个可以PoolChu
netty入门前置知识-NIO
06-25 492
title: Netty入门-第一话 tags: Netty categories: Netty 入门 keywords: Netty description: 第一话对BIO和NIO进行了讲解，为后续做准备。 cover: ‘https://npm.elemecdn.com/lql_static@latest/logo/netty_logo.jpg’ abbrlink: 3f9283e7 date: 2021-04-08 14:21:58 因为学netty的过程中，发现计算机网络和操作系统蛮重.
netty学习--知识点整理
weixin_34290390的博客
04-23 95
Netty中概念的理解 1）Channel：相当于一个Socket连接，类比java nio的SocketChannel；2）EventLoop：反应堆线程，通过非阻塞方式执行I/O任务、定时任务等，类比java nio的Selector；I/O任务和定时任务都被抽象为事件，通过eventloop线程执行；3）EventLoopGroup：反应堆线程组成...
2 深入理解Netty, 线程篇1, 前置知识reactor模型
weixin_39639119的博客
07-10 194
netty 是基于 java nio 上封装的框架，所以它的核心功能一定也是依赖 java nio的核心组件。因为原生java nio太原始，如果要在生产上使用，程序员要花大量的时间在非业务上的处理。如写半包，jdk select的空轮询等等。 netty 从 并行，池化，网络通信等方面帮助我们优化程序。并行可以让我们程序充分利用cpu，今天我们浅析一下netty的线程模型。 这篇文章我们先讲讲什么是 reactor模型： reactor反应堆的...
谈学习netty前的准备
KuaiLeShiFu的博客
11-19 2262
学习netty之前，如果能够学习如下技术，对于快速和深刻学习netty非常有帮助。 需要学习的技术点如下： 1.编解码 2.Reactor模型（三种Reactor模型：Reactor单线程模型、Reactor多线程模型、Reactor主从模型）； 3.pipline模型（无锁串行化设计） 4.Linux零拷贝 5.TCP协议：粘包/拆包问题
Netty学习前篇（一）
程序猿杂货铺
09-18 408
Netty相关API介绍（一） 使用 JDK API 实现一个简单的客户端服务端数据传输案例 OIO （阻塞方式） 服务端代码 import java.io.*; import java.net.ServerSocket; import java.net.Socket; import java.nio.charset.Charset; /** * @author: zhoudonglian...
Netty学习前的知识储备
shayu8nian的博客
12-29 1245
要想学习Netty必须对网络编程要熟悉，其中必须包含几点 1 通讯要素（ip 和端口号，网络通讯协议） 2 InetAdress 类（Scolet基类） 网络编程的主要问题 1 如何找到一台或者多台主机 2 找到主机以后如何更加高效的进行数据传输网络通讯协议
Netty学习前基本知识 — BIO 、NIO 、AIO 总结
org_hjh的博客
10-12 394
点赞再看，养成习惯，微信搜一搜【一角钱技术】关注更多原创技术文章。 本文 GitHub org_hejianhui/JavaStudy 已收录，有我的系列文章。 前言 熟练掌握 BIO、NIO、AIO 的基本概念以及一些常见问题是你准备面试的过程中不可或缺的一部分，另外这些知识点也是你学习 Netty 的基础。 基本概念 IO模型就是说用什么样的通道进行数据的发送和接收，Java 共支持3中网络变成 IO 模式：BIO、NIO、AIO。Java 中的 BIO、NIO 和 AIO 理解为是 Java 语..
Netty学习前置-反应器(Reactor)模式
时间煮茶
05-22 961
目录概览网络服务特性扩展可用需求Divide-and-ConquerReactor 模式单线程版NIO 重要概念ChannelsBuffersSelectorsSelectionKeysReactor实现Setup 创建反应器Dispatch Loop 调度工作循环Acceptor 设计Handler setupRequest handling 请求处理分析:也不知道对不对多线程(池)设计加入线程...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值