Netty 核心原理之运行机制

最新推荐文章于 2024-08-20 14:49:32 发布
最新推荐文章于 2024-08-20 14:49:32 发布
阅读量557 收藏 3
点赞数
分类专栏： NIO netty 文章标签： 多线程 netty java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yewandemty/article/details/106923935
版权
NIO 同时被 2 个专栏收录
5 篇文章 0 订阅
订阅专栏
netty
3 篇文章 0 订阅
订阅专栏
本文深入解析Netty的运行机制，涵盖Reactor线程模型、EventLoopGroup实例化流程、EventLoop任务执行者、EventLoop与Channel的关系及启动流程。详细阐述了Netty中关键组件的功能与交互，为读者提供了全面的Netty核心原理概览。
摘要由CSDN通过智能技术生成

文章目录

Netty 核心原理之运行机制

一、包含的知识点

  • Reactor线程模型
  • EventLoopGroup和Reactor之间的关联
  • EventLoop和Channel的关联
  • EventLoop启动流程

二、Reactor线程模型

​ 在文章 Netty基本原理 中已经大致介绍过Reactor线程模型, 为了和后面内容承上启下, 这里再做一个简单介绍。Reactor主要分为

  • Reactor单线程模型
  • Reactor多线程模型
  • Reactor主从多线程模型

2.1 Reactor单线程模型

​ 单线程模型是指Acceptor和Handler在同一个线程中处理; 这种线程模型存在下面问题

  • 如果某个Handler阻塞, 会导致其它Client的Handler被阻塞, 不能进行业务处理
  • Acceptor也会被阻塞, 不能接受新的Client请求
//单线程模型使用示例代码
EventLoopGroup bossGroup = new NioEventLoopGroup(1);
ServerBootstrap server = new ServerBootstrap();
server.group(bossGroup);

在这里插入图片描述

2.2 Reactor多线程模型

​ 多线程模型和单线程模型区别是, 各个Client连接的IO操作由一组NIO线程提供, Acceptor还是由一个线程来处理, 其特点如下:

  • Acceptor有一个专门的线程用于处理客户端的TCP连接请求
  • 客户端连接的IO操作由一个特定的NIO线程池负责
EventLoopGroup bossGroup = new NioEventLoopGroup(1);
EventLoopGroup workerGroup = new NioEventLoopGroup(100);
ServerBootstrap server = new ServerBootstrap();
server.group(bossGroup, workerGroup);

在这里插入图片描述

Note: 一个Client的IO操作只能由同一个线程执行, 但是一个线程可以处理多个Client的IO操作

2.3 Reactor主从多线程模型

​ Reactor多线程模型的acceptor只有一个线程处理客户端的TCP请求, 如果高并发情况下有大量客户端发起连接请求, 可能造成大量客户端无法连接到服务端。为了解决这个问题, Reactor主从多线程模型, 对接收客户端的连接请求不在是一个线程, 而是一个独立的线程池，即acceptor使用了线程池来处理客户端的请求。

EventLoopGroup bossGroup = new NioEventLoopGroup();
EventLoopGroup workerGroup = new NioEventLoopGroup();
ServerBootstrap server = new ServerBootstrap();
server.group(bossGroup,workerGroup);

在这里插入图片描述

三、EventLoopGroup实例化流程

3.1 EventLoopGroup类继承关系

​ 首先我们看下EventLoopGroup的类继承关系, 然后基于下面的代码分析EventLoopGroup初始化过程。

EventLoopGroup bossGroup = new NioEventLoopGroup();

在这里插入图片描述

3.2 EventLoopGroup创建流程

​ 创建EventLoopGroup时, 通过重载方式创建, 看下下面的代码

//NioEventLoopGroup
public NioEventLoopGroup() {
  this(0);
}

//... 省略部分其它构造函数

public NioEventLoopGroup(int nThreads, Executor executor, final SelectorProvider selectorProvider,
                         final SelectStrategyFactory selectStrategyFactory) {
  //调用的是父类 MultithreadEventLoopGroup 创建NioEventLoopGroup对象
  super(nThreads, executor, selectorProvider, selectStrategyFactory, RejectedExecutionHandlers.reject());
}

//MultithreadEventLoopGroup
protected MultithreadEventLoopGroup(int nThreads, Executor executor, Object... args) {
  // 继续调用父类 MultithreadEventExecutorGroup 进行重建
  super(nThreads == 0 ? DEFAULT_EVENT_LOOP_THREADS : nThreads, executor, args);
}

//MultithreadEventExecutorGroup
protected MultithreadEventExecutorGroup(int nThreads, Executor executor, Object... args) {
  // 创建NioEventLoopGroup的实际入口
  this(nThreads, executor, DefaultEventExecutorChooserFactory.INSTANCE, args);
}

​ 从代码实现和类继承关系, 创建NioEventLoopGroup的入口是MultithreadEventExecutorGroup，下面是具体实现逻辑代码

protected MultithreadEventExecutorGroup(int nThreads, Executor executor,
                                            EventExecutorChooserFactory chooserFactory, Object... args) {
	//省略参数校验逻辑
  children = new EventExecutor[nThreads];

  for (int i = 0; i < nThreads; i ++) {
    boolean success = false;
    try {
      /**
      * 调用抽象方法进行 children 数组创建, NioEventLoopGroup实现创建逻辑, 返回NioEventLoop
      */
      children[i] = newChild(executor, args);
      success = true;
    } catch (Exception e) {
      // TODO: Think about if this is a good exception type
      throw new IllegalStateException("failed to create a child event loop", e);
    } finally {
      //省略服务停止逻辑
    }
  }

  chooser = chooserFactory.newChooser(children);
	
  //创建服务终止监听器Listener
  final FutureListener<Object> terminationListener = new FutureListener<Object>() {
    @Override
    public void operationComplete(Future<Object> future) throws Exception {
      if (terminatedChildren.incrementAndGet() == children.length) {
        terminationFuture.setSuccess(null);
      }
    }
  };
	
  // 给每个children添加刚刚创建的监听器
  for (EventExecutor e: children) {
    e.terminationFuture().addListener(terminationListener);
  }
	
  //创建children的只读副本 childrenSet
  Set<EventExecutor> childrenSet = new LinkedHashSet<EventExecutor>(children.length);
  Collections.addAll(childrenSet, children);
  readonlyChildren = Collections.unmodifiableSet(childrenSet);
}

protected EventLoop newChild(Executor executor, Object... args) throws Exception {
  return new NioEventLoop(this, executor, (SelectorProvider) args[0],
                          ((SelectStrategyFactory) args[1]).newSelectStrategy(), (RejectedExecutionHandler) 		args[2]);
}

3.3 总结

  1. EventLoopGroup的创建逻辑是在MultithreadEventExecutorGroup实现的, 内部维护了一个EventExecutor childrean数组

  2. EventExecutor数组的长度由nThreads指定, 如果给定初始值则由给定值决定, 如果没有给定初始值, 则是CPU核数 * 2

  3. EventExecutor数组是由newChild抽象方法创建, 这个方法的逻辑在NioEventLoopGroup类中实现, 返回NioEventLoop对象

  4. 初始化NioEventLoop主要属性

    4.1 通过args[0] 获得SelectorPrivider对象, 再通过provider对象的openSelector()方法获得Selector对象

    4.2 通过args[1] 获得SelectorStrategyFactory对象, 再通过newSelectStrategy获得对应的具体策略

    4.3 通过args[2] 获得拒绝策略Handler

四、EventLoop任务执行者

4.1 EventLoop类继承关系

​ 在第三节中我们分析知道, MultithreadEventExecutorGroup内部维护了EventExcutor children数组, 数组元素通过newChild创建, 这个方法是一个抽象方法, 是在NioEventLoopGroup实现, 返回NioEventLoop对象, 下面是类即成关系图

在这里插入图片描述

​ 从类继承关系可以看出, NioEventLoopGroup创建的NioEventLoop对象是EventExecutor的子类, 而NioEventLoop继承自SingleThreadEventExecutor类, SingleThreadEventExecutor是Netty的本地线程对象

4.2 SingleThreadEventExecutor

​ SingleThreadEventExecutor是Netty的本地线程对象, 内部维护了一个volatile修饰的Thread对象, 下面是关键的部分代码, thread存储了一个本地java线程, 当创建NioEventLoop对象时, 实际是和一个特定的线程进行绑定, 在生命周期内, 绑定的线程不会改变(从Thread用volatile修饰也可以知道 thread基本是只读的)

private final Queue<Runnable> taskQueue; // 任务队列taskQueue

private volatile Thread thread; // 执行业务逻辑线程thread
@SuppressWarnings("unused")
private volatile ThreadProperties threadProperties; //线程属性
private final Executor executor; // 线程池对象root
private volatile boolean interrupted; // 中断标志

private final Semaphore threadLock = new Semaphore(0);
private final Set<Runnable> shutdownHooks = new LinkedHashSet<Runnable>(); // 钩子, 停止线程
private final boolean addTaskWakesUp;
private final int maxPendingTasks; // 最大pending任务数量
private final RejectedExecutionHandler rejectedExecutionHandler; // 线程拒绝策略handler

private long lastExecutionTime; // 上次执行时间

@SuppressWarnings({ "FieldMayBeFinal", "unused" })
private volatile int state = ST_NOT_STARTED;

private volatile long gracefulShutdownQuietPeriod; //平滑停止服务优先级
private volatile long gracefulShutdownTimeout; //平滑停止服务超时时间
private long gracefulShutdownStartTime; // 平滑停止服务开始时间

4.3 NioEventLoop作用

​ NioEventLoop有两个作用

  • 第一个任务是作为IO线程, 执行Channel相关的IO操作, 实际调用Selector上等待就绪的事件
  • 执行taskQueue队列中的任务, 或eventLoop.schedule提交的任务队列

​ 从之前讲解Channel和Selector知识, 对上面第一点比较容易理解, 对第二点提交的定时任务处理怎么理解呢?

  1. NioEventLoop实例的execute()方法向任务队列taskQueue添加任务, 并进行调度执行
  2. NioEventLoop的类继承关系, NioEventLoop -> SingleThreadEventLoop -> SingleThreadEventExecutor -> AbstractScheduledEventExecutor, 在AbstractScheduledEventExecutor抽象类中有个任务队列变量, 如下，在SingleThreadEventLoop类又实现了任务队列功能
Queue<ScheduledFutureTask<?>> scheduledTaskQueue;

4.4 线程启动流程

​ NioEventLoop启动时会执行run方法, 如果当前选择策略是SelectStrategy.SELECT, 会执行select方法

protected void run() {
        for (;;) {
            try {
                switch (selectStrategy.calculateStrategy(selectNowSupplier, hasTasks())) {
                    case SelectStrategy.CONTINUE:
                        continue;
                    case SelectStrategy.SELECT: // 如果KEY是 SELECT, 执行select操作
                        select(wakenUp.getAndSet(false));
                        if (wakenUp.get()) {
                            selector.wakeup();
                        }
                    default:
                        // fallthrough
                }

               // ... 省略其它代码
    }

​ 在进行select操作时,如果需要rebuild操作，会执行rebuildSelector()方法

private void select(boolean oldWakenUp) throws IOException {
        Selector selector = this.selector;
        try {
            int selectCnt = 0;
            long currentTimeNanos = System.nanoTime();
            long selectDeadLineNanos = currentTimeNanos + delayNanos(currentTimeNanos);
            for (;;) {
                // ... 省略部分其它代码

                long time = System.nanoTime();
                if (time - TimeUnit.MILLISECONDS.toNanos(timeoutMillis) >= currentTimeNanos) {
                    // timeoutMillis elapsed without anything selected.
                    selectCnt = 1;
                } else if (SELECTOR_AUTO_REBUILD_THRESHOLD > 0 &&
                        selectCnt >= SELECTOR_AUTO_REBUILD_THRESHOLD) { // 自动rebuild阈值>0, 且selectCnt>阈值, 进行rebuild操作
                    // The selector returned prematurely many times in a row.
                    // Rebuild the selector to work around the problem.
                    logger.warn(
                            "Selector.select() returned prematurely {} times in a row; rebuilding Selector {}.",
                            selectCnt, selector);

                    rebuildSelector();
                    selector = this.selector;

                    // Select again to populate selectedKeys.
                    selector.selectNow();
                    selectCnt = 1;
                    break;
                }

                currentTimeNanos = time;
            }

            // ...省略部分其它代码
    }

​ 因为启动时主线程和当前调用线程是不一样的，初始时刻 inEventLoop()方法为false 查看下面代码

public boolean inEventLoop(Thread thread) {
  return thread == this.thread;
}

​ 因为inEventLoop为false, 会执行execute方法，

public void rebuildSelector() {
  if (!inEventLoop()) {
    execute(new Runnable() {
      @Override
      public void run() {
        rebuildSelector();
      }
    });
    return;
  }
  // ... 省略其它代码
}

public void execute(Runnable task) {
  if (task == null) {
    throw new NullPointerException("task");
  }

  boolean inEventLoop = inEventLoop();
  if (inEventLoop) {
    addTask(task);
  } else {
    startThread(); // 线程启动
    addTask(task); // 将任务添加到taskQueue队列中
    if (isShutdown() && removeTask(task)) {
      reject();
    }
  }

  if (!addTaskWakesUp && wakesUpForTask(task)) {
    wakeup(inEventLoop);
  }
}

​ 因为inEventLoop为false, 会执行else对应的逻辑，执行startThread方法进行线程启动, 实际执行的是doStartThread方法, 启动线程逻辑是SingleThreadEventExecutor.this.run(), 实现类在NioEventLoop, 和本小节开始时分析相对应。

private void doStartThread() {
        assert thread == null;
        executor.execute(new Runnable() {
            @Override
            public void run() {
                thread = Thread.currentThread();
                if (interrupted) {
                    thread.interrupt();
                }

                boolean success = false;
                updateLastExecutionTime();
                try {
                    SingleThreadEventExecutor.this.run(); // 启动线程, 抽象方法，NioEventLoop是对应的实现, 
                    success = true;
                } catch (Throwable t) {
                    logger.warn("Unexpected exception from an event executor: ", t);
                } finally {
                    // ... 省略部分代码
            }
        });
    }

五、EventLoop和Channel关系

5.1 ServerBootStrap服务启动

​ ServerBootStrap服务在启动后会进行服务启动和register操作, 查看下面的代码示例

ServerBootstrap server = new ServerBootstrap();
server.group(bossGroup,workerGroup);
server.bind(port) ;

​ 服务通过bind进行端口绑定和服务启动操作, 内部实际调用的是doBind()、bind0()操作

//AbstractBootstrap
public ChannelFuture bind(SocketAddress localAddress) {
  validate();
  if (localAddress == null) {
    throw new NullPointerException("localAddress");
  }
  return doBind(localAddress);
}


//
private ChannelFuture doBind(final SocketAddress localAddress) {
  final ChannelFuture regFuture = initAndRegister(); // 核心: 将Channel和EventLoop进行绑定操作
  final Channel channel = regFuture.channel();
  if (regFuture.cause() != null) {
    return regFuture;
  }

  // ... 省略其它bind0() 操作
}


//初始话Channel并和NioEventLoop绑定
final ChannelFuture initAndRegister() {
  Channel channel = null;
  try {
    channel = channelFactory.newChannel(); // ChannelFactory创建Channel
    init(channel);
  } catch (Throwable t) {
    if (channel != null) {
      // channel can be null if newChannel crashed (eg SocketException("too many open files"))
      channel.unsafe().closeForcibly();
    }
    // as the Channel is not registered yet we need to force the usage of the GlobalEventExecutor
    return new DefaultChannelPromise(channel, GlobalEventExecutor.INSTANCE).setFailure(t);
  }

  ChannelFuture regFuture = config().group().register(channel); // channel和NioEventLoop绑定核心逻辑
  return regFuture;
}

5.2 EventLoopGroup创建

​ config()是一个抽象类， 分别根据ServerBoostrap、Bootstrap有不同的实现, 这里以ServerBootStrap为例进行说明, 方法执行后会创建ServerBootstrapConfig

public final ServerBootstrapConfig config() {
  return config; // 返回 ServerBootstrapConfig
}

​ ServerBootstrapConfig继承自AbstractBootstrapConfig, 在AbstractBootstrapConfig类中, 通过下面的代码创建EventLoopGroup对象

//ServerBootstrap
private final ServerBootstrapConfig config = new ServerBootstrapConfig(this); // this就是ServerBootStrap

//ServerBootstrapConfig
public final EventLoopGroup group() {
  return bootstrap.group();
}

//AbstractBootStrap <- ServerBootstrap
public final EventLoopGroup group() {
  return group; // group是bossGroup(EventLoopGroup)
}

​ EventLoopGroup是一个抽象类, 其核心子类是MultithreadEventLoopGroup, 内部通过register方法将Channel和EventLoopGroup进行绑定，查看接口调用

//MultithreadEventLoopGroup -> EventLoopGroup
public ChannelFuture register(Channel channel) {
  return next().register(channel);
}

//SingleThreadEventLoop
public ChannelFuture register(Channel channel) {
  return register(new DefaultChannelPromise(channel, this));
}

public ChannelFuture register(final ChannelPromise promise) {
  ObjectUtil.checkNotNull(promise, "promise");
  // 通过unsafe方法进行注册, 将EventLoop和Channel绑定
  // 这里unsafe是Netty自己定义的接口, 不是操作系统native操作Unsafe
  promise.channel().unsafe().register(this, promise); 
  return promise;
}

5.3 EventLoop启动流程补充

​ 在4.4节中, 我们初步分析了EventLoop的启动流程, 这里再做一个补充。 从4.2节我们知道NioEventLoop的父类SingleThreadEventExecutor内部维护了一个Thread, 因此NioEventLoop的启动实际是对这个thread的启动，我们知道thread的启动是通过thread.start()来启动的，现在从这个思路在SingleThreadEventExecutor类中进行查询, 发现下面的代码

private void startThread() {
  if (STATE_UPDATER.get(this) == ST_NOT_STARTED) {
    if (STATE_UPDATER.compareAndSet(this, ST_NOT_STARTED, ST_STARTED)) {
      doStartThread();
    }
  }
}

​ STATE_UPDATER是一个原子类集合, 内部维护了线程状态, 初始时刻线程状态是ST_NOT_STARTED, 会执行if条件内部的逻辑, 在CAS成功后会执行doStartThread()方法, 进行线程启动

private static final AtomicIntegerFieldUpdater<SingleThreadEventExecutor> STATE_UPDATER;

​ startThread方法是私有方法, 它是在execute方法调用的，下面是源码, 因为服务启动是在主线程中运行的, 下面代码走else逻辑, 执行startThread操作, 并将task加入taskQueue队列中。

public void execute(Runnable task) {
  if (task == null) {
    throw new NullPointerException("task");
  }

  boolean inEventLoop = inEventLoop();
  if (inEventLoop) {
    addTask(task);
  } else {
    startThread();
    addTask(task);
    if (isShutdown() && removeTask(task)) {
      reject();
    }
  }

  if (!addTaskWakesUp && wakesUpForTask(task)) {
    wakeup(inEventLoop);
  }
}

​ 那么execute()什么时候会被调用呢 ?

在4.4节中我们分析知道，如果需要rebuildSelector, 会执行execute方法; 除此之外，Channel和EventLoop进行register绑定的时候, 也会执行execute方法， 查看下面代码, 服务启动是在主线程中执行的, 进行NIO操作的Thread和主线程不同, 会执行else逻辑, 最后执行EventLoop的execute方法

//AbstractChannel
public final void register(EventLoop eventLoop, final ChannelPromise promise) {
  // 省略部分其它代码
  AbstractChannel.this.eventLoop = eventLoop;

  if (eventLoop.inEventLoop()) { // 主线程启动和当前线程不同, 返回false
    register0(promise);
  } else {
    try {
      eventLoop.execute(new Runnable() {
        @Override
        public void run() {
          register0(promise);
        }
      });
    } catch (Throwable t) {
      logger.warn(
        "Force-closing a channel whose registration task was not accepted by an event loop: {}",
        AbstractChannel.this, t);
      closeForcibly();
      closeFuture.setClosed();
      safeSetFailure(promise, t);
    }
  }
}

​ 总结: 当EventLoop执行execute方法时, 会触发startThread方法调用, 进而对Java本地线程启动。

六、ServerBoostrap EventLoop启动流程图

在这里插入图片描述

夜晚的猫头鹰
关注
专栏目录
03-Netty运行原理
Stay Hungry, Stay Foolish!
04-14 389
文章目录一、创建Netty程序1.1 服务端1.2 客户端1.3 启动测试二、Netty运行原理2.1 Netty启动与运行流程2.2 Netty运行原理 文章放置于：https://github.com/zgkaii/CS-Study-Notes，欢迎批评指正！ 一、创建Netty程序 1.1 服务端 public class EchoServer { static final int PORT = Integer.parseInt(System.getProperty("port", "88
Netty核心原理
Yan__Ran的博客
07-15 1577
NIO学习完，发现一个问题就是---使用起来就很麻烦，几个小demo给我搞得眼花缭乱....这时Netty出现了。
netty的基本运行原理
Xjzzon的博客
07-01 349
netty BIO的缺陷 一个socket由一个线程处理，大量socket引起创建大量线程。 数据读写是以字节流为单位，效率不高 NIO 线程切换效率 NIO编程模型中，新来一个连接不再创建一个新的线程，而是可以把这条连接直接绑定到某个固定的线程，然后这条连接所有的读写都由这个线程来负责。一条连接来了之后，现在不创建一个while死循环去监听是否有数据可读了，而是直接把这条连接注册到selector上，然后，通过检查这个selector，就可以批量监测出有数据可读的连接，进而读取数据。 IO读写
深入剖析 Netty 核心原理
最新发布
2401_84664550的博客
08-20 841
Netty 是一个基于 Java NIO 技术的网络应用框架，它提供了一套简洁而强大的 API，用于构建高性能、可扩展的网络应用程序。Netty 具有异步非阻塞、事件驱动、高度可定制等特点，能够轻松应对高并发、大流量的网络通信场景。
一文理解Netty模型架构
weixin_34082789的博客
11-01 1291
作者 陈彩华 贝聊后端开发工程师 文章转载交流请联系 caison@aliyun.com 复制代码本文基于Netty4.1展开介绍相关理论模型，使用场景，基本组件、整体架构，知其然且知其所以然，希望给读者提供学习实践参考。 1 Netty简介 Netty是 一个异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。 JDK原生NIO程序的问题 JDK原生也有一套网络应用...
Netty 具体使用与 Netty原理及其运行方式
m0_46582888的博客
04-03 576
Netty 的特点与 NIO 最近在重新看netty，在这里总结一些netty的一些常用的使用方式。 对于高性能的 RPC 框架，Netty 作为异步通信框架，几乎成为必备品。例如，Dubbo 框架中通信组件，还有 RocketMQ 中生产者和消费者的通信，都使用了 Netty。今天，我们来看看 Netty 的基本架构和原理。 Netty 是一个异步的、基于事件驱动的网络应用框架，它可以用来开发高...
protoBuf
Java 日常积累
01-08 197
  1. 简介 Netty 是一个异步的，事件驱动的网络编程框架和工具，使用Netty 可以快速开发出可维护的，高性能、高扩展能力的协议服务及其客户端应用。 也就是说，Netty 是一个基于NIO的客户，服务器端编程框架，使用Netty 可以确保你快速和简单的开发出一个网络应用，例如实现了某种协议的客户，服务端应用。Netty相当简化和流线化了网络应用的编程开发过程，例如，TCP和UDP的s...
Netty之Pipeline的原理和事件传播机制
yewandemty的博客
06-28 1907
Netty之Pipeline的原理和事件传播机制 文章目录Netty之Pipeline的原理和事件传播机制一、包含知识点二、 Channel和Pipeline之间关系三、ChannelPipeline初始化流程3.1 Channel初始化流程3.2 Pipeline实例化3.3 Pipeline实例化后图示四、ChannelInitializer添加4.1 init添加自定义handler、childHandler4.2 handler转ChannelHandlerContext4.3 init之后pipe
Netty实现原理浅析.pdf
05-24
### Netty实现原理浅析 #### 一、总体结构概览 Netty是一个高性能的Java NIO框架，由JBoss出品。它不仅提供了一套完整的客户端和服务端开发工具集，而且具备高度可定制化的特点，使得开发者能够轻松构建出可靠且...
跟闪电侠学Netty：Netty即时聊天实战与底层原理-book-netty.zip
11-07
7. **Netty底层原理**：探讨Netty如何利用Java NIO实现异步非阻塞I/O，以及零拷贝技术的工作机制，帮助读者理解Netty的高效性。 8. **案例分析**：通过实际项目案例，展示Netty在实际场景中的应用，如P2P下载、...
netty架构与原理
祥哥
01-05 743
前言 1. Netty 基础 1.4.1. 缓冲区（Buffer） 1.4.2. 通道（Channel） 1.4.3. 选择器（Selector） 1.1. Netty 是什么 1.2. Netty 的应用场景 1.3. Java 中的网络 IO 模型 1.4. Java NIO API 简单回顾 1.5. 零拷贝技术 2. Netty 的架构与原理 2.2.1. 单 Reactor 单线程模式 2.2.2. 单 Reactor 多线程模式 2.2.3. 主从
Netty机制
baidu_38376402的博客
05-10 316
Netty 是一个基于NIO的客户、服务器端编程框架，使用Netty 可以确保你快速和简单的开发出一个网络应用，例如实现了某种协议的客户，服务端应用。Netty相当简化和流线化了网络应用的编程开发过程，例如，TCP和UDP的socket服务开发。...
netty核心原理
Cruise的博客
06-05 533
Netty核心原理 Netty介绍 原生 NIO 存在的问题 NIO 的类库和 API 繁杂，使用麻烦：需要熟练掌握 Selector、ServerSocketChannel、 SocketChannel、ByteBuffer等。 需要具备其他的额外技能：要熟悉 Java 多线程编程，因为 NIO 编程涉及到 Reactor 模式，你必须 对多线程和网络编程非常熟悉，才能编写出高质量的 NIO 程序。 开发工作量和难度都非常大：例如客户端面临断连重连、网络闪断、半包读写、失败缓存、网络拥 塞和异常流的处理
Netty核心原理(一）
weixin_62017112的博客
07-19 1251
1.Netty是由JBOSS提供的一个Java开源框架。Netty提供异步的、基于事件驱动的网络应用程序框架，用以快速开发高性能、高可靠性的网络IO程序。2.Netty是一个基于NIO的网络编程框架，使用Netty可以帮助你快速、简单的开发出一个网络应用，相当于简化和流程化了NIO的开发过程。不同的线程模式，对程序的性能有很大影响，在学习Netty线程模式之前，我们首先来了解一夏各个线程模式，最后看看Netty线程模型有什么优越性.目前存在的线程模型有。......
Netty运行原理简述
三3三的博客
06-17 373
netty运行原理简述，有流程图有文字分析
netty核心原理是什么
大连赵哥的博客
05-11 174
netty核心原理是什么
Netty之框架原理分析(一)
贾红平
06-23 9494
1 netty原理2 编程模型3 线程模型
"深度解析Netty高性能之道：核心原理与调优方案
在第4章《Netty高性能之道》中，我们将深入了解Netty的运行机制，掌握NioEventLoop、Pipeline和ByteBuf的核心原理，并学习Netty常见的调优方案。 本课程适合有深度了解Netty源码需求的人群，也适合未来可能参与...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值