doStartThread() — netty Function Reference

Source Code

common/src/main/java/io/netty/util/concurrent/SingleThreadEventExecutor.java lines 1178–1306

    private void doStartThread() {
        executor.execute(new Runnable() {
            @Override
            public void run() {
                processingLock.lock();
                assert thread == null;
                thread = Thread.currentThread();
                if (interrupted) {
                    thread.interrupt();
                    interrupted = false;
                }
                boolean success = false;
                Throwable unexpectedException = null;
                updateLastExecutionTime();
                boolean suspend = false;
                try {
                    for (;;) {
                        SingleThreadEventExecutor.this.run();
                        success = true;

                        int currentState = state;
                        if (canSuspend(currentState)) {
                            if (!STATE_UPDATER.compareAndSet(SingleThreadEventExecutor.this,
                                    ST_SUSPENDING, ST_SUSPENDED)) {
                                // Try again as the CAS failed.
                                continue;
                            }

                            if (!canSuspend(ST_SUSPENDED) && STATE_UPDATER.compareAndSet(SingleThreadEventExecutor.this,
                                        ST_SUSPENDED, ST_STARTED)) {
                                // Seems like there was something added to the task queue again in the meantime but we
                                // were able to re-engage this thread as the event loop thread.
                                continue;
                            }
                            suspend = true;
                        }
                        break;
                    }
                } catch (Throwable t) {
                    unexpectedException = t;
                    logger.warn("Unexpected exception from an event executor: ", t);
                } finally {
                    boolean shutdown = !suspend;
                    if (shutdown) {
                        for (;;) {
                            // We are re-fetching the state as it might have been shutdown in the meantime.
                            int oldState = state;
                            if (oldState >= ST_SHUTTING_DOWN || STATE_UPDATER.compareAndSet(
                                    SingleThreadEventExecutor.this, oldState, ST_SHUTTING_DOWN)) {
                                break;
                            }
                        }
                        if (success && gracefulShutdownStartTime == 0) {
                            // Check if confirmShutdown() was called at the end of the loop.
                            if (logger.isErrorEnabled()) {
                                logger.error("Buggy " + EventExecutor.class.getSimpleName() + " implementation; " +
                                        SingleThreadEventExecutor.class.getSimpleName() + ".confirmShutdown() must " +
                                        "be called before run() implementation terminates.");
                            }
                        }
                    }

                    try {
                        if (shutdown) {
                            // Run all remaining tasks and shutdown hooks. At this point the event loop
                            // is in ST_SHUTTING_DOWN state still accepting tasks which is needed for
                            // graceful shutdown with quietPeriod.
                            for (;;) {
                                if (confirmShutdown()) {
                                    break;
                                }
                            }

                            // Now we want to make sure no more tasks can be added from this point. This is
                            // achieved by switching the state. Any new tasks beyond this point will be rejected.
                            for (;;) {
                                int currentState = state;
                                if (currentState >= ST_SHUTDOWN || STATE_UPDATER.compareAndSet(
                                        SingleThreadEventExecutor.this, currentState, ST_SHUTDOWN)) {
                                    break;
                                }