Netty4.0源码分析：NioEventLoop/NioEventLoopGroup的任务处理流程

最新推荐文章于 2024-04-05 19:53:09 发布
最新推荐文章于 2024-04-05 19:53:09 发布
阅读量1k 收藏 2
点赞数
分类专栏： Netty
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/abc123lzf/article/details/83313530
版权

一、引言

在上篇文章中我们讨论了NioEventLoop/NioEventLoopGroup的构造过程，这篇文章我们来分析NioEventLoop/NioEventLoopGroup的运行过程。

NioEventLoop/NioEventLoopGroup的构造流程：
https://blog.csdn.net/abc123lzf/article/details/83245134

二、源码解析

在Netty中，NioEventLoop（包括所有的SingleThreadEventExecutor子类）有两个职责：一是作为IO线程处理IO事件，二是作为普通的线程处理通过execute等方法提交上来的任务。

一个NioEventLoop实例包含以下字段(Field)：

修饰符字段名作用
Queue<ScheduledFutureTask<?>>scheduledTaskQueue该EventExecutor存放待执行的定时任务的任务队列
private final EventExecutorGroupparent该EventLoop所属的EventExecutorGroup(EventLoopGroup)
private final Queue <Runnable>taskQueue存放待执行任务的队列
private final Threadthread该EventLoop对应的线程，在构造方法中通过线程工厂构造
private final ThreadPropertiesthreadProperties存储线程属性的对象(例如是否为后台线程、线程优先级等)
private final SemaphorethreadLock信号量，在这里用于加锁，初始值为new Semaphore(0)
private final booleanaddTaskWakeUp是否在添加任务后立刻唤醒线程
private final intmaxPendingTasks最大保存的尚未执行任务的数量，超出这个数量后继续提交任务会转交给拒绝执行处理器处理
private final RejectedExecutionHandlerrejectedExecutionHandler拒绝执行处理器，用于处理当前EventLoop拒绝执行的任务
private longlastExecutionTime线程运行的时间点
private volatile intstateEventLoop的状态，初始值是ST_NOT_STARTED
private volatile longgracefulShutdownQuietPeriod时间相关变量，用于关闭EventLoop
private volatile longgracefulShutdownTimeout时间相关变量，用于关闭EventLoop
private volatile longgracefulShutdownStartTime时间相关变量，用于关闭EventLoop
private final Promise<?>terminationFuturePromise实现类，用于异步操作
private SelectorselectorSelector对象，一般为SelectedSelectionKeySetSelector对象，也可能就是unwrappedSelector
private SelectorunwrappedSelector未经包装的Selector选择器，由SelectorProvider对象的openSelector方法获得
private SelectedSelectionKeySetselectedKeys存储该Selector所有的SelectorKey的对象
private final SelectorProviderprovider构造时指定的SelectorProvider，用于生成Selector对象
private final AtomicBooleanwakenUp是否唤醒Selector
private final SelectStrategyselectStrategySelector的选择策略
private final IntSupplierselectNowSupplier用于SelectStrategy对象
private final Callable<Integer>pendingTasksCallableCallable任务对象，任务逻辑为获取任务队列的长度
private volatile intioRatio事件循环中IO操作所需时间的百分比，默认为50
private intcancelledKeys持有的SelectionKey对象被取消的数量
private booleanneedsToSelectAgain是否需要重新选择

当我们调用NioEventLoop的execute方法提交任务时，线程随即会被启动。
execute方法在服务端中会被很多个地方调用，比如AbstractUnsafe中的方法，DefaultPromise的notifyListeners方法、AbstractBootstrap的doBind0方法等。

@Override
public void execute(Runnable task) {
    if (task == null)
        throw new NullPointerException("task");
    //当前线程是不是就是这个NioEventLoop持有的线程
    boolean inEventLoop = inEventLoop();
    //如果是就直接往任务队列中添加任务
    if (inEventLoop) {
        addTask(task);
    //否则尝试启动这个线程并添加到任务队列中
    } else {
        startThread();
        addTask(task);
        //如果线程池已经被关闭，那么移除这个任务对象，然后抛出RejectedExecutionException
        if (isShutdown() && removeTask(task)) {
            reject();
        }
    }

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

execute方法首先判断当前线程是不是这个NioEventLoop持有的线程，如果是，就直接将Runnable任务对象添加到任务队列中。如果不是，就启动当前线程，再将任务添加到任务队列中。
startThread方法：

private void startThread() {
    if (state == ST_NOT_STARTED) { //如果线程没有启动
    	//通过CAS改变state变量，然后调用start方法启动线程
        if (STATE_UPDATER.compareAndSet(this, ST_NOT_STARTED, ST_STARTED)) {
            thread.start();
        }
    }
}

成员变量thread的实例化在SingleThreadEventExecutor构造阶段：

thread = threadFactory.newThread(new Runnable() {
    @Override
    public void run() {
        boolean success = false;
        //更新这个线程开始运行的时间
        updateLastExecutionTime();
        try {
        	//调用SingleThreadEventExecutor的run方法
            SingleThreadEventExecutor.this.run();
            success = true;
        } catch (Throwable t) {
            logger.warn("Unexpected exception from an event executor: ", t);
        } finally {
        	//省略线程即将死亡后的处理...
        }
    }
});

SingleThreadEventExecutor的run方法在SingleThreadEventExecutor是一个抽象方法，其具体实现在NioEventLoop中：

@Override
protected void run() {
    for (;;) {
        try {
        	//通过选择策略器决定是否执行任务
            switch (selectStrategy.calculateStrategy(selectNowSupplier, hasTasks())) {
                case SelectStrategy.CONTINUE:
                    continue;
                case SelectStrategy.SELECT:
                	//将wakenUp变量设为false，并调用select方法
                    select(wakenUp.getAndSet(false));
                    //如果此时wakenUp为true，那么中断此时调用Selector的selector方法的线程
                    if (wakenUp.get()) {
                        selector.wakeup();
                    }
                default:
            }
            cancelledKeys = 0;
            needsToSelectAgain = false;
            final int ioRatio = this.ioRatio;
            if (ioRatio == 100) { //如果IO操作时间百分比为100，那么就默认处理所有任务
                try {
                	//优先处理SelectorKey
                    processSelectedKeys();
                } finally {
                	//运行所有任务
                    runAllTasks();
                }
            } else {
                final long ioStartTime = System.nanoTime();
                try {
                    processSelectedKeys();
                } finally {
                    final long ioTime = System.nanoTime() - ioStartTime;
                    //执行任务的时间为ioTime的(100-ioRation)%
                    runAllTasks(ioTime * (100 - ioRatio) / ioRatio);
                }
            }
        } catch (Throwable t) {
            handleLoopException(t);
        }
        try {
            if (isShuttingDown()) {
                closeAll();
                if (confirmShutdown())
                    return;
            }
        } catch (Throwable t) {
            handleLoopException(t);
        }
    }
}

run方法执行步骤可以分为：
1、首先调用构造时指定的选择策略器的calculateStrategy方法。
一般来说SelectStrategy都是采用默认的DefaultSelectStrategyFactory.INSTANCE返回的实例：

final class DefaultSelectStrategy implements SelectStrategy {
    static final SelectStrategy INSTANCE = new DefaultSelectStrategy();
    private DefaultSelectStrategy() { } //单例模式
    @Override
    public int calculateStrategy(IntSupplier selectSupplier, boolean hasTasks) throws Exception {
        return hasTasks ? selectSupplier.get() : SelectStrategy.SELECT;
    }
}

如果此时任务队列为空，那么直接返回SelectStrategy.SELECT，否则返回selectSupplier变量的get方法的返回值
对于IntSupplier，NioEventLoop实现了自己的IntSupplier：

private final IntSupplier selectNowSupplier = new IntSupplier() {
	@Override
    public int get() throws Exception {
        return selectNow();
    }
};

int selectNow() throws IOException {
    try {
        return selector.selectNow();
    } finally {
        if (wakenUp.get()) {
            selector.wakeup();
        }
    }
}

IntSupplier通过调用Selector的selectNow方法以非阻塞的方式来获知有多少个Channel通道就绪。在方法返回前，如果将wakenUp的值设为true，那么调用wakeup方法中断调用select方法被阻塞的线程。

如果calculateStrategy方法返回的是SelectStrategy.SELECT，那么将wakenUp的值改为false，然后调用select方法。select方法通过一个循环等待有就绪的Channel通道，或者两个任务队列不为空时才会退出循环继续执行，如果循环次数超过了512次，那么就会调用rebuildSelector方法重构Selector。

2、调用processSelectedKeys方法处理Selector上注册的Channel，即处理IO事件
3、调用runAllTasks方法处理其它提交的任务

1、IO事件的处理机制

NioEventLoop的IO事件处理集成了ServerSocketChannel和ServerSocket的IO事件处理。

private void processSelectedKeys() {
    if (selectedKeys != null) {
        processSelectedKeysOptimized();
    } else {
        processSelectedKeysPlain(selector.selectedKeys());
    }
}

如果在初始化过程中设置了selectedKeys，那么调用processSelectedKeysOptimized处理注册的Channel（在绝大多数运行环境下都会执行这个方法，也就是selectedKeys不会为null，所以限于篇幅不介绍processSelectedKeysPlain方法了）：

private void processSelectedKeysOptimized() {
	//遍历这个Selector所有的SelectorKeys
    for (int i = 0; i < selectedKeys.size; ++i) {
        final SelectionKey k = selectedKeys.keys[i];
        //移除这个SelectionKey
        selectedKeys.keys[i] = null;
        //获取这个SelectionKey的附加对象
        final Object a = k.attachment();
        //如果这个附加对象是Netty的AbstractNioChannel的子类
        if (a instanceof AbstractNioChannel) {
            processSelectedKey(k, (AbstractNioChannel) a);
        //否则就是NioTask的实现类
        } else {
            @SuppressWarnings("unchecked")
            NioTask<SelectableChannel> task = (NioTask<SelectableChannel>) a;
            processSelectedKey(k, task);
        }
        if (needsToSelectAgain) {
            selectedKeys.reset(i + 1);
            selectAgain();
            i = -1;
        }
    }
}

简单地说，processSelectedKeysOptimized方法通过一个循环遍历selectedKeys中的SelectionKey集合获取就绪的IO事件，然后调用processSelectedKey方法处理这些IO事件。
这个方法对每个SelectionKey都调用了它的attachment方法获取它的附加对象，这个附加对象要么就是AbstractNioChannel，要么就是NioTask接口实现类。那么这个附加对象是在什么时候设置的呢？
答案就在AbstractNioChannel的doRegister方法中：

selectionKey = javaChannel().register(eventLoop().unwrappedSelector(), 0, this);

这个方法会在引导过程中被调用。
这个Channel和SelectionKey的关系就是这个SelectionKey属于这个Channel。

回到processSelectedKeysOptimized方法，我们再来看processSelectedKey方法是如何处理IO事件的：

private void processSelectedKey(SelectionKey k, AbstractNioChannel ch) {
    final NioUnsafe unsafe = ch.unsafe(); //获取它的Unsafe对象
    //如果这个SelectionKey不是有效的(在SelectionKey被取消，通道关闭或选择器关闭之前，SelectionKey都是有效的)
    if (!k.isValid()) { 
        final EventLoop eventLoop;
        try {
            eventLoop = ch.eventLoop();
        } catch (Throwable ignored) {
            return;
        }    
        if (eventLoop != this || eventLoop == null)
            return;
        unsafe.close(unsafe.voidPromise());
        return;
    }

    try {
        int readyOps = k.readyOps(); //获取已经准备就绪的操作事件
        //如果为连接建立事件
        if ((readyOps & SelectionKey.OP_CONNECT) != 0) {
            int ops = k.interestOps();
            //从事件集中移除这个事件
            ops &= ~SelectionKey.OP_CONNECT;
            k.interestOps(ops);
            //通知Unsafe构建连接
            unsafe.finishConnect();
        }
        //如果通道是可写的
        if ((readyOps & SelectionKey.OP_WRITE) != 0) {
            ch.unsafe().forceFlush();
        }
        //如果通道是可读的或者是可以接受连接的，那么调用Unsafe的read方法
        if ((readyOps & (SelectionKey.OP_READ | SelectionKey.OP_ACCEPT)) != 0 || readyOps == 0) {
            unsafe.read();
        }
    } catch (CancelledKeyException ignored) {
        unsafe.close(unsafe.voidPromise());
    }
}

processSelectedKey可以处理SelectionKey所有的IO事件：OP_ACCEPT，OP_CONNECT，OP_READ，OP_WRITE

OP_CONNECT事件的处理
对于SelectionKey的OP_CONNECT事件，processSelectedKey方法会调用Unsafe实现类的finishConnect建立连接（该方法位于AbstractNioChannel的AbstractNioUnsafe类中）：

@Override
public final void finishConnect() {
	assert eventLoop().inEventLoop();
    try {
        boolean wasActive = isActive();
        doFinishConnect();
        fulfillConnectPromise(connectPromise, wasActive);
    } catch (Throwable t) {
        fulfillConnectPromise(connectPromise, annotateConnectException(t, requestedRemoteAddress));
    } finally {
        if (connectTimeoutFuture != null) {
            connectTimeoutFuture.cancel(false);
        }
        connectPromise = null;
    }
}

doFinishConnect实现在子类NioSocketChannel中：

@Override
protected void doFinishConnect() throws Exception {
	if (!javaChannel().finishConnect()) {
        throw new Error();
    }
}

doFinishConnect方法调用了java.nio.SocketChannel的finishConnect方法确认通道连接已经建立。

private void fulfillConnectPromise(ChannelPromise promise, boolean wasActive) {
    if (promise == null)
        return;
    boolean active = isActive();
    boolean promiseSet = promise.trySuccess();
    if (!wasActive && active)
        pipeline().fireChannelActive();
    if (!promiseSet)
        close(voidPromise());
}

fulfillConnectPromise方法首先通知DefaultChannelPromise的监听器连接已成功建立，然后向管道中的ChannelInboundHandler传播Channel Active事件（即调用管道的fireChannelActive方法）

OP_READ和OP_ACCPET事件的处理
虽然看上去OP_READ和OP_ACCPET事件都采用了read方法处理，但需要注意的是，只有当当前的NioEventLoop持有ServerSocketChannel时，它的SelectionKey才会发出OP_ACCPET事件，，那么它调用的read方法来自于NioMessageUnsafe（AbstractNioMessageChannel的内部类）。否则，则是SocketChannel发出的OP_READ事件，那么read方法来自NioByteUnsafe类（AbstractNioByteChannel的内部类）。

我们先从NioMessageUnsafe的read方法开始分析（即ServerSocketChannel处理OP_ACCEPT事件）：

@Override
public void read() {
    assert eventLoop().inEventLoop();
    final ChannelConfig config = config();
    if (!config.isAutoRead() && !isReadPending()) {
    	//从事件集中移除这个事件
        removeReadOp();
        return;
    }
    //获取每个循环读取的最大消息数(SocketChannel)
    final int maxMessagesPerRead = config.getMaxMessagesPerRead();
    final ChannelPipeline pipeline = pipeline();
    boolean closed = false;
    Throwable exception = null;
    try {
        try {
            for (;;) {
            	//将对应的SocketChannel添加到readBuf中，返回1
                int localRead = doReadMessages(readBuf);
                if (localRead == 0) {
                    break;
                }
                if (localRead < 0) {
                    closed = true;
                    break;
                }
                if (!config.isAutoRead())
                    break;
                //如果readBuf的长度大于maxMessagesPerRead，退出循环
                if (readBuf.size() >= maxMessagesPerRead)
                    break;
            }
        } catch (Throwable t) {
            exception = t;
        }
        setReadPending(false);
        //将SocketChannel传递给ChannelInboundHandler
        int size = readBuf.size();
        for (int i = 0; i < size; i ++)
            pipeline.fireChannelRead(readBuf.get(i));
        //清除这些读取到的ByteBuf，并调用ChannelInboundHandler的fireChannelReadComplete方法
        readBuf.clear();
        pipeline.fireChannelReadComplete();
        //如果发生异常，调用ChannelInboundHandler的fireExceptionCaught方法
        if (exception != null) {
            closed = closeOnReadError(exception);
            pipeline.fireExceptionCaught(exception);
        }
        if (closed)
            if (isOpen())
                close(voidPromise());
    } finally {
    	//再次检查这个事件有没有从事件集中去除
        if (!config.isAutoRead() && !isReadPending()) {
            removeReadOp();
        }
    }
}

NioMessageUnsafe维护了一个List集合readBuf，readBuf存放了ServerSocketChannel获取的SocketChannel，每个SocketChannel对应一个客户端连接。下面来分析read方法主要过程：
1、调用doReadMessages方法获取客户端连接的SocketChannel，并添加到readBuf中：

@Override
protected int doReadMessages(List<Object> buf) throws Exception {
    SocketChannel ch = SocketUtils.accept(javaChannel());
    try {
    	//将ServerSocketChannel和NioServerSocketChannel封装为一个
    	//NioSocketChannel对象，然后添加到readBuf中
        if (ch != null) {
            buf.add(new NioSocketChannel(this, ch));
            return 1;
        }
    } catch (Throwable t) { //发生异常则关闭Channel
        logger.warn("Failed to create a new channel from an accepted socket.", t);
        try {
            ch.close();
        } catch (Throwable t2) {
            logger.warn("Failed to close a socket.", t2);
        }
    }
    return 0;
}

2、调用这个ServerSocketChannel所属的ChannelPipleine的fireChannelRead方法，产生一个进站事件，通过第一个注册的进站处理器（ChannelInboundHandler）开始流经管道，流经管道的msg为SocketChannel实例。对于具有bossGroup和workGroup的服务端程序来说，其流经的ChannelInboundHandler的顺序为：
HeadContext -> ServerBootstrap内部类ServerBootstrapAcceptor -> 用户自定义管道 ->TailContext

3、调用这个ServerSocketChannel所属的ChannelPipleine的fireChannelReadComplete方法，产生一个进站处理完成事件，同样通过第一个注册的进站处理器（ChannelInboundHandler）开始流经管道，顺序同上。

4、如果在获取SocketChannel发生异常，那么产生一个异常事件，将这个异常对象通过ChannelPipeline的fireExceptionCaught方法传递给ChannelInboundHandler。

分析完ServerSocketChannel的read方法处理流程后，我们再来分析SocketChannel的处理流程，即NioByteUnsafe的read方法：

@Override
public final void read() {
    final ChannelConfig config = config();
    //如果这个方法是手动调用的(默认是自动调用的)，那么移除这个OP_READ事件并返回
    if (!config.isAutoRead() && !isReadPending()) {
        removeReadOp();
        return;
    }
    //获取持有的管道、缓冲区分配器
    final ChannelPipeline pipeline = pipeline();
    final ByteBufAllocator allocator = config.getAllocator();
    //获取最大的尝试读取次数
    final int maxMessagesPerRead = config.getMaxMessagesPerRead();
    RecvByteBufAllocator.Handle allocHandle = this.allocHandle;
    if (allocHandle == null) {
        this.allocHandle = allocHandle = config.getRecvByteBufAllocator().newHandle();
    }

    ByteBuf byteBuf = null;
    int messages = 0;
    boolean close = false;
    try {
        int totalReadAmount = 0;
        boolean readPendingReset = false;
        do {
        	//通过缓冲区分配器创建一个ByteBuf缓冲区
            byteBuf = allocHandle.allocate(allocator);
            //返回分配的缓冲区大小
            int writable = byteBuf.writableBytes();
            //向缓冲区读入Channel包含的可读数据，返回读入字节数
            int localReadAmount = doReadBytes(byteBuf);
            //如果没有可读入的数据或者读取失败，那么释放ByteBuf
            if (localReadAmount <= 0) {
                byteBuf.release();
                byteBuf = null;
                close = localReadAmount < 0;
                if (close)
                    setReadPending(false);
                break;
            }
            if (!readPendingReset) {
                readPendingReset = true;
                setReadPending(false);
            }
            //向管道传入持有读入数据的ByteBuf对象
            pipeline.fireChannelRead(byteBuf);
            byteBuf = null;
            //防止数字溢出
            if (totalReadAmount >= Integer.MAX_VALUE - localReadAmount) {
                totalReadAmount = Integer.MAX_VALUE;
                break;
            }
            totalReadAmount += localReadAmount;
            if (!config.isAutoRead())
                break;
            //如果没有数据可读了，那么退出循环
            if (localReadAmount < writable) 
                break;
        //如果循环次数小于最大的尝试读取次数，那么继续尝试读取
        } while (++messages < maxMessagesPerRead);
        //读取完毕，向管道发出读入完成事件
        pipeline.fireChannelReadComplete();
        //记录本次读取的字节数量，在下次读入时分配一个更合适的缓冲区大小避免浪费内存或多次分配内存
        allocHandle.record(totalReadAmount);
        //如果通道关闭
        if (close) {
            closeOnRead(pipeline);
            close = false;
        }
    } catch (Throwable t) {
    	//如果有异常抛出，那么向管道发出读入完成事件和读入异常事件
        handleReadException(pipeline, byteBuf, t, close);
    } finally {
    	//保证OP_READ事件已经移除
        if (!config.isAutoRead() && !isReadPending())
            removeReadOp();
    }
}

read方法步骤如下：
1、获取这个Channel持有的管道、缓冲区分配器。
2、通过缓冲区分配器分配一个ByteBuf缓冲区
3、通过就绪的NIO Channel通道读入到缓冲区。读入成功后，向管道发出channelRead事件并将包含读入数据的缓冲区实例传入，如果已经没有可读入的数据了（读入字节数小于缓冲区可写容量），那么退出循环。
4、如果循环次数小于最大的尝试读取次数，那么从第2步开始继续循环。
5、向管道发出读入完成事件（通过调用fireChannelReadComplete方法）

OP_WRITE事件
OP_WRITE事件只有SocketChannel才会发出。
对于OP_WRITE事件，会调用Unsafe实现类的forceFlush方法写入通道，forceFlush方法默认调用flush0方法：

protected void flush0() {
    if (inFlush0) //如果正在写入，那么方法退出
        return;
    final ChannelOutboundBuffer outboundBuffer = this.outboundBuffer;
    //如果出站处理器还尚未往缓冲区中写入数据，那么方法结束
    if (outboundBuffer == null || outboundBuffer.isEmpty())
        return;
    inFlush0 = true;
    if (!isActive()) { //如果Channel通道不可用
        try {
            if (isOpen()) //如果Channel是打开的，那么发出一个尚未连接的异常事件
                outboundBuffer.failFlushed(FLUSH0_NOT_YET_CONNECTED_EXCEPTION, true);
            else //否则发出已经关闭连接的异常的事件
                outboundBuffer.failFlushed(FLUSH0_CLOSED_CHANNEL_EXCEPTION, false);
        } finally {
            inFlush0 = false;
        }
        return;
    }    
    try { //调用doWrite写入数据
        doWrite(outboundBuffer);
    } catch (Throwable t) {
        //省略异常处理代码...
    } finally {
        inFlush0 = false;
    }
}

doWrite方法实现在AbstractNioByteChannel中：

@Override
protected void doWrite(ChannelOutboundBuffer in) throws Exception {
    int writeSpinCount = -1;
    boolean setOpWrite = false;
    for (;;) {
    	//获取需要往Channel通道写入的数据
        Object msg = in.current();
        if (msg == null) {
            clearOpWrite();
            return;
        }
        //如果msg为ByteBuf缓冲区
        if (msg instanceof ByteBuf) {
            ByteBuf buf = (ByteBuf) msg;
            //获取缓冲区存放的字节数
            int readableBytes = buf.readableBytes();
            if (readableBytes == 0) { //如果缓冲区为空，那么释放内存
                in.remove();
                continue;
            }
            boolean done = false;
            long flushedAmount = 0;
            //获取循环写入次数，默认为16
            if (writeSpinCount == -1)
                writeSpinCount = config().getWriteSpinCount();
            //写入NIO Channel通道
            for (int i = writeSpinCount - 1; i >= 0; i--) {
                int localFlushedAmount = doWriteBytes(buf);
                if (localFlushedAmount == 0) {
                    setOpWrite = true;
                    break;
                }
                flushedAmount += localFlushedAmount;
                if (!buf.isReadable()) {
                    done = true;
                    break;
                }
            }
            //通知ChannelPromise
            in.progress(flushedAmount);
            if (done)
                in.remove();
            else
                break;
        } else if (msg instanceof FileRegion) {
            //省略FileRegion的处理
        } else {
            throw new Error();
        }
    }
    incompleteWrite(setOpWrite);
}
2、一般任务的处理

回到NioEventLoop，当执行完IO事件时，就会调用runAllTasks执行一般任务：

protected boolean runAllTasks() {
    boolean fetchedAll;
    do {
        fetchedAll = fetchFromScheduledTaskQueue();
        Runnable task = pollTask(); //从任务队列中取出任务
        if (task == null) //如果没有可执行的任务则返回false
            return false;
		//从任务队列中取出任务并执行任务
        for (;;) {
            try {
                task.run();
            } catch (Throwable t) {
                logger.warn("A task raised an exception.", t);
            }

            task = pollTask();
            if (task == null)
                break;
        }
    } while (!fetchedAll); 
    lastExecutionTime = ScheduledFutureTask.nanoTime();
    return true;
}

因为EventLoop既需要处理IO事件，也需要执行一般任务， 因此我们最好不要向EventLoop提交耗时任务，提交这些任务会导致IO事件处理时间下降，影响到系统的吞吐量。

A__Plus
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Netty 入门与实战：仿写微信 IM 即时通讯系统
06-26
Netty 入门与实战：仿写微信 IM 即时通讯系统
netty4.0 之 EventLoop
airu的专栏
12-17 111
在此之前，我们回顾下传统的网络编程。也就是socket。 socket编程中，客户端是发起连接的，服务端呢就监听某一个端口。 一档客户端连接被监听到，就在客户端和服务端建立一个连接，于是他们就可以传数据了。 NIO利用操作系统中的select，epoll等系统特性，避开了线程的开销和限制，由操作系统在数据到来时通知Selector， 当然NIO使用起来，还是需要自己去写一些框架性质的东西，不...
Netty之EventLoop和EventLoopGroup(七)
FJJJJJ
08-12 2451
Netty的线程模型 Reactor单线程模型 Reactor单线程模型，是指所有的IO操作都在同一个NIO线程上面完成。NIO线程的职责如下： 作为NIO服务端，接收客户端的TCP连接； 作为NIO客户端，向服务端发起TCP连接； 读取通信对端的请求或者应答消息； 向通信对端发送消息请求或者应答消息。 由于 Reactor模式使用的是异步非阻塞I/O，所有的IO操作都不会导致阻塞，理论上一个线程可以独立处理所有IO相关的操作。从架构层面看，一个NIO线程确实可以完成其承担的职责。例如，通过 Acce
Netty NioEventLoop详解
最新发布
老码农的博客
04-05 1326
Netty通过事件循环机制(EventLoop)处理IO事件和异步任务，简单来说，就是通过一个死循环，不断处理当前已发生的IO事件和待处理的异步任务。① NioEventLoop是一个基于JDK NIO的异步事件循环类，它负责处理一个Channel的所有事件在这个Channel的生命周期期间。② NioEventLoop的整个生命周期只会依赖于一个单一的线程来完成。
EventLoopGroup执行普通任务定时任务
胖揍偷猪贼&的博客
03-28 372
EventLoopGroup执行普通任务定时任务
netty学习1：NioEventLoopGroup 事件循环组源码分析
weixin_45453628的博客
05-18 1249
netty学习1：NioEventLoopGroup 事件循环组源码分析
【Netty权威指南】14-NioEventLoop和NioEventLoopGroup
通往神秘的道路的专栏
04-30 1万+
1、Netty的线程模型 当我们讨论 Netty线程模型的时候,一般首先会想到的是经典的 Reactor线程模型,尽管不同的NIO框架对于 Reactor模式的实现存在差异,但本质上还是遵循了 Reactor的基础线程模型。 下面让我们一起回顾经典的 Reactor线程模型。 1.1、Reactor单线程模型 Reactor单线程模型,是指所有的IO操作都在同一个NIO线程上面完成。NIO线...
netty4.0源码，netty例子，netty api文档
07-20
包含javadoc，jar 两个文件夹。 doc中是文档资料。 jar是源码及常用例子，均好源码，好使。
Netty核心之Channel源码学习
01-20
Channel服务端启动核心路径总结 1.newChannel()创建Channel对象 2.Init()初始化预设参数 ...4.doBind()绑定端口 反射创建服务端Channel 1.newSocket()[通过jdk来创建底层jdk channel] 2.NioServerSocketChannelCobfig()...
Netty （netty-netty-4.0.56.Final.tar.gz）
02-17
Netty （netty-netty-4.0.56.Final.tar.gz）是一个 NIO 客户端服务器框架，可以快速轻松地开发协议服务器和客户端等网络应用程序。它极大地简化和流线了网络编程，例如 TCP 和 UDP 套接字服务器。 “快速和简单”并...
Netty4.0学习笔记系列之四：混合使用coder和handler
06-10
NULL 博文链接：https://bijian1013.iteye.com/blog/2340636
xxljob中执行器配置错误导致的NioEventLoopGroup未被正确回收的oom分析和解决
huang007guo的专栏
11-15 4547
xxljob中执行器配置错误导致的NioEventLoopGroup未被正确回收的oom分析和解决 一. mat内存分析 报告中NioEventLoop占用了1.2g的容量,大部分的堆空间 定位NioEventLoop正确的被引用位置应该为下图所示 NioEventLoopGroup正确的被引用位置为下图所示 但发现大量的NioEventLoopGroup没有被正确引用,却也没有回收掉 故初步定位为:NettyHttpConnectClient 下的grou...
netty源码之NioEventLoopGroup
qq_32868023的博客
06-05 215
NioEventLoopGroup是netty的一个重要组件，NioEventLoopGroup主要完成3个事情相关的类、接口如图 EventExecutorGroup除了shutdown相关方法，有两类重要方法 EventLoopGroup EventLoopGroup接口继承了EventExecutorGroup，还做了两件事情 AbstractEventExecutorGroup AbstractEventExecutorGroup实现了EventExecutorGroup接口，实现了里面的大部分方法
NioEventLoopGroup源码解读
sclgxy0的博客
05-06 232
NioEventLoopGroup其实就是reactor模式中的reactor的角色，本节我们先来看看NioEventLoopGroup在new的过程当中做了哪些事情 使用new创建NioEventLoopGroup时，会经过一系列构造方法调用，最终调用到上图中5个参数的构造方法，该构造方法会调用到父类MultithreadEventLoopGroup的构造方法，其中线程数如果不传，默认为cpu个...
Netty源码解读（三）-NioEventLoop
王谷雨的博客
06-16 125
我们在Netty第二篇文章中的代码中，看到有多次用到eventLoop.execute()方法，这个方法就是EventLoop开启线程执行任务的关键
NioEventLoop源码分析
weixin_45271492的博客
12-01 900
前面几期带大家分析了Netty的服务端启动，客户端连接，客户端消息处理的流程，本期就来讲解Netty中一个极其重要的组件，事件循环器EventLoop。 NioEventLoopGroup分析 我们平常使用Netty的时候，一般都是用NioEventLoopGroup进行操作，所以我们从NioEventLoopGroup开始分析。首先来看一下NioEventLoopGroup的继承体系 从上图可以看出NioEventLoopGroup是一个线程池，所以有一个execute()方法，并且实现了Schedul
netty实战之百万级流量NioEventLoopGroup线程数配置
热门推荐
Sam_Deep_Thinking
08-30 3万+
编写netty服务端程序的时候,会使用到两个线程组 EventLoopGroup parentGroup = new NioEventLoopGroup(); EventLoopGroup childGroup = new NioEventLoopGroup(); 那么parentGroup和childGroup分别应该设置多少个线程呢?关于netty的线程组概念,李林锋的Netty系
NioEventLoopGroup初始化
weixin_30606669的博客
07-15 336
本文是我对Netty的NioEventLoopGroup及NioEventLoop初始化工作的源码阅读笔记, 如下图,是Netty的Reactor线程模型图,本文描述NioEventLoopGroup等价于我在图中标红的MainReactor组件,全篇围绕它的初始化展开,难免地方理解的不正确,欢迎留言 在Nio网络编程模型的图示是下面那张图, 单条Thread全职执行一个Selecto...
Netty4学习笔记-- NioEventLoopGroup NioEventLoop
z69183787的专栏
09-22 5320
NioEventLoopGroup继承层次结构图 Netty4的NioEventLoopGroup继承结构很复杂，为了理解它如何工作，我画了一张类似UML的图。但是这张图也很巨大，所以我做了以下处理： 将位于不同包中的类或接口用不同的颜色加以区分 接口名后面的括号里标注了大写字母I（Interface），抽象类名的后面标注了大写字母A（Abstract）
netty 接收 Content-Type:image/xxx 类型的数据
07-23
如果你想在Netty中接收Content-Type为`image/xxx`类型的数据，你可以按照以下步骤进行操作： 1. 创建一个自定义的ChannelHandler来处理HTTP请求。你可以扩展Netty的`SimpleChannelInboundHandler`类，并重写`...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值