EmbeddedUnsafe Class — netty Architecture

Source Code

transport/src/main/java/io/netty/channel/embedded/EmbeddedChannel.java lines 1189–1334

    private final class EmbeddedUnsafe extends AbstractUnsafe {

        // Delegates to the EmbeddedUnsafe instance but ensures runPendingTasks() is called after each operation
        // that may change the state of the Channel and may schedule tasks for later execution.
        final Unsafe wrapped = new Unsafe() {
            @Override
            public RecvByteBufAllocator.Handle recvBufAllocHandle() {
                return EmbeddedUnsafe.this.recvBufAllocHandle();
            }

            @Override
            public SocketAddress localAddress() {
                return EmbeddedUnsafe.this.localAddress();
            }

            @Override
            public SocketAddress remoteAddress() {
                return EmbeddedUnsafe.this.remoteAddress();
            }

            @Override
            public void register(EventLoop eventLoop, ChannelPromise promise) {
                executingStackCnt++;
                try {
                    EmbeddedUnsafe.this.register(eventLoop, promise);
                } finally {
                    executingStackCnt--;
                    maybeRunPendingTasks();
                }
            }

            @Override
            public void bind(SocketAddress localAddress, ChannelPromise promise) {
                executingStackCnt++;
                try {
                    EmbeddedUnsafe.this.bind(localAddress, promise);
                } finally {
                    executingStackCnt--;
                    maybeRunPendingTasks();
                }
            }

            @Override
            public void connect(SocketAddress remoteAddress, SocketAddress localAddress, ChannelPromise promise) {
                executingStackCnt++;
                try {
                    EmbeddedUnsafe.this.connect(remoteAddress, localAddress, promise);
                } finally {
                    executingStackCnt--;
                    maybeRunPendingTasks();
                }
            }

            @Override
            public void disconnect(ChannelPromise promise) {
                executingStackCnt++;
                try {
                    EmbeddedUnsafe.this.disconnect(promise);
                } finally {
                    executingStackCnt--;
                    maybeRunPendingTasks();
                }
            }

            @Override
            public void close(ChannelPromise promise) {
                executingStackCnt++;
                try {
                    EmbeddedUnsafe.this.close(promise);
                } finally {
                    executingStackCnt--;
                    maybeRunPendingTasks();
                }
            }

            @Override
            public void closeForcibly() {
                executingStackCnt++;
                try {
                    EmbeddedUnsafe.this.closeForcibly();
                } finally {