Netty_01

最新推荐文章于 2024-05-17 13:43:01 发布

李李子-

最新推荐文章于 2024-05-17 13:43:01 发布

阅读量36

点赞数

文章标签： dubbo java 开发语言

本文链接：https://blog.csdn.net/weixin_51001722/article/details/131016836

版权

一、 Netty 的介绍

1) Netty 是由 JBOSS 提供的一个 Java 开源框架，现为 Github 上的独立项目。

2) Netty 是一个异步的、基于事件驱动的网络应用框架，用以快速开发高性能、高可靠性的网络 IO 程序。

3) Netty 主要针对在 TCP 协议下，面向 Clients 端的高并发应用，或者 Peer-to-Peer 场景下的大量数据持续传输的

应用。

4) Netty 本质是一个 NIO 框架，适用于服务器通讯相关的多种应用场景

1.3 Netty 的应用场景

1.3.1互联网行业

1) 互联网行业：在分布式系统中，各个节点之间需要远程服务调用，高性能的 RPC 框架必不可少，Netty 作为

异步高性能的通信框架，往往作为基础通信组件被这些 RPC 框架使用。

2) 典型的应用有：阿里分布式服务框架 Dubbo 的 RPC 框架使用 Dubbo 协议进行节点间通信，Dubbo 协议默

认使用 Netty 作为基础通信组件，用于实现各进程节点之间的内部通信

1.3.2游戏行业

1) 无论是手游服务端还是大型的网络游戏，Java 语言得到了越来越广泛的应用

2) Netty 作为高性能的基础通信组件，提供了 TCP/UDP 和 HTTP 协议栈，方便定制和开发私有协议栈，账号登

录服务器

3) 地图服务器之间可以方便的通过 Netty 进行高性能的通信

1.3.3大数据领域

1) 经典的 Hadoop 的高性能通信和序列化组件 Avro 的 RPC 框架，默认采用 Netty 进行跨界点通信

2) 它的 Netty Service 基于 Netty 框架二次封装实现。

二、Java BIO 编程

2.1 I/O 模型

2.1.1 I/O 模型基本说明

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

2) Java 共支持 3 种网络编程模型/IO 模式：BIO、NIO、AIO

3) Java BIO ：同步并阻塞(传统阻塞型)，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器

端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销

同步阻塞模型，一个客户端连接对应一个处理线程

4) Java NIO ：同步非阻塞，服务器实现模式为一个线程处理多个请求(连接)，即客户端发送的连接请求都会注

册到多路复用器上，多路复用器轮询到连接有 I/O 请求就进行处理，JDK1.4开始引入。

NIO底层在JDK1.4版本是用linux的内核函数select()或poll()来实现，跟上面的NioServer代码类似，selector每次都会轮询所有的

sockchannel看下哪个channel有读写事件，有的话就处理，没有就继续遍历，JDK1.5开始引入了epoll基于事件响应机制来优化NIO。

NioSelectorServer 代码里如下几个方法非常重要，我们从Hotspot与Linux内核函数级别来理解下

1 Selector.open() //创建多路复用器
2 socketChannel.register(selector, SelectionKey.OP_READ) 
    //将channel注册到多路复用器上
3 selector.select() //阻塞等待需要处理的事件发生

总结：NIO整个调用流程就是Java调用了操作系统的内核函数来创建Socket，获取到Socket的文件描述符，再创建一个Selector对象，对应操作系统的Epoll描述符，将获取到的Socket连接的文件描述符的事件绑定到Selector对应的Epoll文件描述符上，进行事件的异步通知，这样就实现了使用一条线程，并且不需要太多的无效的遍历，将事件处理交给了操作系统内核(操作系统中断程序实现)，大大提高了效率。

Epoll函数详解

1 int epoll_create(int size);

创建一个epoll实例，并返回一个非负数作为文件描述符，用于对epoll接口的所有后续调用。参数size代表可能会容纳size个描述符，但size不是一个最大值，只是提示操作系统它的数量级，现在这个参数基本上已经弃用了。

1 int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

使用文件描述符epfd引用的epoll实例，对目标文件描述符fd执行op操作。

参数epfd表示epoll对应的文件描述符，参数fd表示socket对应的文件描述符。

参数op有以下几个值：

EPOLL_CTL_ADD：注册新的fd到epfd中，并关联事件event；

EPOLL_CTL_MOD：修改已经注册的fd的监听事件；

EPOLL_CTL_DEL：从epfd中移除fd，并且忽略掉绑定的event，这时event可以为null；

参数event是一个结构体

1 struct epoll_event {
2 __uint32_t events; /* Epoll events */
3 epoll_data_t data; /* User data variable */
4 };
5
6 typedef union epoll_data {
7 void *ptr;
8 int fd;
9 __uint32_t u32;
10 __uint64_t u64;
11 } epoll_data_t;

events有很多可选值，这里只举例最常见的几个：

EPOLLIN ：表示对应的文件描述符是可读的；

EPOLLOUT：表示对应的文件描述符是可写的；

EPOLLERR：表示对应的文件描述符发生了错误；

成功则返回0，失败返回-1

1 int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);

等待文件描述符epfd上的事件。

epfd是Epoll对应的文件描述符，events表示调用者所有可用事件的集合，maxevents表示最多等到多少个事件就返回，timeout是超时时间。

I/O多路复用底层主要用的Linux 内核函数（select，poll，epoll）来实现，windows不支持epoll实现，windows底层是基于winsock2的

select函数实现的(不开源)

select、poll 和 epoll 什么区别

它们是 NIO 多路复用的三种实现机制，是有 Linux 系统提供。

select：无差别轮询所有流，找出能读出数据，或者写入数据的流，对他们进行操作，会

维护一个文件描述符 FD 的集合 fd_set，将 fd_set 从用户空间复制到内核空间。x86

fd_set 是数组结构，(上限1024)

poll：与 select 机制相似，fd_set 结构进行优化，突破操作系统限制，pollfd 代替

fd_set，链表结构

epoll：不再扫描所以 fd，只将用户关心的事件放在内核的一个事件表中，减少用户空间

和内核空间的数据拷贝。epoll 可以理解为 event poll，不同于忙轮询和无差别轮询，

epoll 会把哪个流发生了怎样的 I/O 事件通知我们。

Redis线程模型

Redis就是典型的基于epoll的NIO线程模型(nginx也是)，epoll实例收集所有事件(连接与读写事件)，由一个服务端线程连续处理所有事件

命令。

Redis底层关于epoll的源码实现在redis的src源码目录的ae_epoll.c文件里

5) Java AIO(NIO.2) ：异步非阻塞，AIO 引入异步通道的概念，采用了 Proactor 模式，简化了程序编写，有效

的请求才启动线程，它的特点是先由操作系统完成后才通知服务端程序启动线程去处理，一般适用于连接数较

多且连接时间较长的应用

2.2 BIO、NIO、AIO 适用场景分析

1) BIO 方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4

以前的唯一选择，但程序简单易理解。

2) NIO 方式适用于连接数目多且连接比较短（轻操作）的架构，比如聊天服务器，弹幕系统，服务器间通讯等。

编程比较复杂，JDK1.4 开始支持。

3) AIO 方式使用于连接数目多且连接比较长（重操作）的架构，比如相册服务器，充分调用 OS 参与并发操作，

编程比较复杂，JDK7 开始支持。

2.3 Java BIO 基本介绍

1) Java BIO 就是传统的 java io 编程，其相关的类和接口在 java.io

2) BIO(blocking I/O) ：同步阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需

要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，可以通过线程池机制改善(实

现多个客户连接服务器)。

3) BIO 方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4

以前的唯一选择，程序简单易理解

2.4 Java BIO 工作机制

对 BIO 编程流程的梳理

1) 服务器端启动一个 ServerSocket

2) 客户端启动 Socket 对服务器进行通信，默认情况下服务器端需要对每个客户建立一个线程与之通讯

3) 客户端发出请求后, 先咨询服务器是否有线程响应，如果没有则会等待，或者被拒绝

4) 如果有响应，客户端线程会等待请求结束后，在继续执行

2.5 Java BIO 应用实例

实例说明：

1) 使用 BIO 模型编写一个服务器端，监听 6666 端口，当有客户端连接时，就启动一个线程与之通讯。

2) 要求使用线程池机制改善，可以连接多个客户端. 3) 服务器端可以接收客户端发送的数据(telnet 方式即可)。

4) 代码

public class BIOServer {
    public static void main(String[] args) throws Exception {
        //线程池机制
        //思路
        //1. 创建一个线程池
        //2. 如果有客户端连接，就创建一个线程，与之通讯(单独写一个方法)
        ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
        //创建ServerSocket
        ServerSocket serverSocket = new ServerSocket(6666);
        System.out.println("服务器启动了");
        while (true) {
            System.out.println("线程信息 id =" + Thread.currentThread().getId() + " 名字=" + Thread.currentThread().getName());
            //监听，等待客户端连接
            System.out.println("等待连接....");
            final Socket socket = serverSocket.accept();
            System.out.println("连接到一个客户端");
            //就创建一个线程，与之通讯(单独写一个方法)
            newCachedThreadPool.execute(new Runnable() {
                public void run() { //我们重写
                    //可以和客户端通讯
                    handler(socket);
                }
            });
        }
    }
    //编写一个handler方法，和客户端通讯
    public static void handler(Socket socket) {

        try {
            System.out.println("线程信息 id =" + Thread.currentThread().getId() + " 名字=" + Thread.currentThread().getName());
            byte[] bytes = new byte[1024];
            //通过socket 获取输入流
            InputStream inputStream = socket.getInputStream();

            //循环的读取客户端发送的数据
            while (true) {

                System.out.println("线程信息 id =" + Thread.currentThread().getId() + " 名字=" + Thread.currentThread().getName());

                System.out.println("read....");
                int read =  inputStream.read(bytes);
                if(read != -1) {
                    System.out.println(new String(bytes, 0, read
                                                 )); //输出客户端发送的数据
                } else {
                    break;
                }
            }
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            System.out.println("关闭和client的连接");
            try {
                socket.close();
            }catch (Exception e) {
                e.printStackTrace();
            }

        }
    }
}

2.6 Java BIO 问题分析

1) 每个请求都需要创建独立的线程，与对应的客户端进行数据 Read，业务处理，数据 Write 。

2) 当并发数较大时，需要创建大量线程来处理连接，系统资源占用较大。

3) 连接建立后，如果当前线程暂时没有数据可读，则线程就阻塞在 Read 操作上，造成线程资源浪费

李李子-

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Netty_01

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

扫一扫