DefaultKqueueIoRegistration Class — netty Architecture

Source Code

transport-classes-kqueue/src/main/java/io/netty/channel/kqueue/KQueueIoHandler.java lines 424–517

    private final class DefaultKqueueIoRegistration implements IoRegistration {
        private boolean cancellationPending;
        private final AtomicBoolean canceled = new AtomicBoolean();
        private final KQueueIoEvent event = new KQueueIoEvent();

        final KQueueIoHandle handle;
        final long id;
        private final ThreadAwareExecutor executor;

        DefaultKqueueIoRegistration(ThreadAwareExecutor executor, KQueueIoHandle handle) {
            this.executor = executor;
            this.handle = handle;
            id = generateNextId();
        }

        boolean isHandleForChannel() {
            return handle instanceof AbstractKQueueChannel.AbstractKQueueUnsafe;
        }

        @SuppressWarnings("unchecked")
        @Override
        public <T> T attachment() {
            return (T) nativeArrays;
        }

        @Override
        public long submit(IoOps ops) {
            KQueueIoOps kQueueIoOps = cast(ops);
            if (!isValid()) {
                return -1;
            }
            short filter = kQueueIoOps.filter();
            short flags = kQueueIoOps.flags();
            int fflags = kQueueIoOps.fflags();
            if (executor.isExecutorThread(Thread.currentThread())) {
                evSet(filter, flags, fflags);
            } else {
                executor.execute(() -> evSet(filter, flags, fflags));
            }
            return 0;
        }

        void handle(int ident, short filter, short flags, int fflags, long data, long udata) {
            if (cancellationPending) {
                // This registration was already cancelled but not removed from the map yet, just ignore.
                return;
            }
            event.update(ident, filter, flags, fflags, data, udata);
            handle.handle(this, event);
        }

        private void evSet(short filter, short flags, int fflags) {
            if (cancellationPending) {
                // This registration was already cancelled but not removed from the map yet, just ignore.
                return;
            }
            changeList.evSet(handle.ident(), filter, flags, fflags, 0, id);
        }

        @Override
        public boolean isValid() {
            return !canceled.get();
        }

        @Override
        public boolean cancel() {
            if (!canceled.compareAndSet(false, true)) {
                return false;
            }
            if (executor.isExecutorThread(Thread.currentThread())) {
                cancel0();
            } else {
                executor.execute(this::cancel0);
            }
            return true;
        }

        private void cancel0() {
            // Let's add the registration to our cancelledRegistrations queue so we will process it
            // after we processed all events. This is needed as otherwise we might end up removing it
            // from the registration map while we still have some unprocessed events.