DefaultEpollIoRegistration Class — netty Architecture

Source Code

transport-classes-epoll/src/main/java/io/netty/channel/epoll/EpollIoHandler.java lines 231–319

    private final class DefaultEpollIoRegistration implements IoRegistration {
        private final ThreadAwareExecutor executor;
        private final AtomicBoolean canceled = new AtomicBoolean();
        final EpollIoHandle handle;

        DefaultEpollIoRegistration(ThreadAwareExecutor executor, EpollIoHandle handle) {
            this.executor = executor;
            this.handle = handle;
        }

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

        @Override
        public long submit(IoOps ops) {
            EpollIoOps epollIoOps = cast(ops);
            try {
                if (!isValid()) {
                    return -1;
                }
                Native.epollCtlMod(epollFd.intValue(), handle.fd().intValue(), epollIoOps.value);
                return epollIoOps.value;
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }
        }

        @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() {
            int fd = handle.fd().intValue();
            DefaultEpollIoRegistration old = registrations.remove(fd);
            if (old != null) {
                if (old != this) {
                    // The Channel mapping was already replaced due FD reuse, put back the stored Channel.
                    registrations.put(fd, old);
                    return;
                } else if (old.handle instanceof AbstractEpollChannel.AbstractEpollUnsafe) {
                    numChannels--;
                }
                if (handle.fd().isOpen()) {
                    try {
                        // Remove the fd registration from epoll. This is only needed if it's still open as otherwise
                        // it will be automatically removed once the file-descriptor is closed.
                        Native.epollCtlDel(epollFd.intValue(), fd);
                    } catch (IOException e) {
                        logger.debug("Unable to remove fd {} from epoll {}", fd, epollFd.intValue());
                    }
                }
                handle.unregistered();
            }
        }

        void close() {
            try {
                cancel();
            } catch (Exception e) {
                logger.debug("Exception during canceling " + this, e);
            }
            try {
                handle.close();
            } catch (Exception e) {