Package io.netty.channel

Class ManualIoEventLoop

    • Method Detail

      • runNonBlockingTasks

        public int runNonBlockingTasks​(long timeoutNanos)
        Poll and run tasks from the task queue, until the task queue is empty or the given deadline is exceeded.
        If timeoutNanos is less or equals 0, no deadline is applied.
        Parameters:
        timeoutNanos - the maximum time in nanoseconds to run tasks.

      • runNow

        public int runNow​(long runAllTasksTimeoutNanos)
        Executes all ready IO and tasks for this IoEventLoop. This methods will NOT block and wait for IO / tasks to be ready, it will just return directly if there is nothing to do.

        Must be called from the owning Thread that was passed as a parameter on construction.

        Parameters:
        runAllTasksTimeoutNanos - the maximum time in nanoseconds to run tasks. If = 0, no timeout is applied; if < 0 it just perform I/O tasks.
        Returns:
        the number of IO and tasks executed.
        Throws:
        java.lang.IllegalStateException - if the method is not called from the owning Thread.

      • runNow

        public int runNow()
        Run all ready IO and tasks for this IoEventLoop. This methods will NOT block and wait for IO / tasks to be ready, it will just return directly if there is nothing to do.

        Must be called from the owning Thread that was passed as a parameter on construction.

        Returns:
        the number of IO and tasks executed.

      • run

        public int run​(long waitNanos,
               long runAllTasksTimeoutNanos)
        Run all ready IO and tasks for this IoEventLoop. This methods will block and wait for IO / tasks to be ready if there is nothing to process atm for the given waitNanos.

        Must be called from the owning Thread that was passed as an parameter on construction.

        Parameters:
        runAllTasksTimeoutNanos - the maximum time in nanoseconds to run tasks. If = 0, no timeout is applied; if < 0 it just perform I/O tasks.
        waitNanos - the maximum amount of nanoseconds to wait before returning. IF 0 it will block until there is some IO / tasks ready, if -1 will not block at all and just return directly if there is nothing to run (like runNow()).
        Returns:
        the number of IO and tasks executed.

      • run

        public int run​(long waitNanos)
        Run all ready IO and tasks for this IoEventLoop. This methods will block and wait for IO / tasks to be ready if there is nothing to process atm for the given waitNanos.

        Must be called from the owning Thread that was passed as an parameter on construction.

        Parameters:
        waitNanos - the maximum amount of nanoseconds to wait before returning. IF 0 it will block until there is some IO / tasks ready, if -1 will not block at all and just return directly if there is nothing to run (like runNow()).
        Returns:
        the number of IO and tasks executed.

      • wakeup

        public void wakeup()
        Force a wakeup and so the run(long) method will unblock and return even if there was nothing to do.

      • inEventLoop

        public boolean inEventLoop​(java.lang.Thread thread)
        Description copied from interface: EventExecutor
        Return true if the given Thread is executed in the event loop, false otherwise.
        Specified by:
        inEventLoop in interface EventExecutor

      • setOwningThread

        public void setOwningThread​(java.lang.Thread owningThread)
        Set the owning thread that will call run(io.netty.channel.IoHandlerContext, long). May only be called once, and only if the owning thread was not set in the constructor already.
        Parameters:
        owningThread - The owning thread

      • shutdownGracefully

        public Future<?> shutdownGracefully​(long quietPeriod,
                                    long timeout,
                                    java.util.concurrent.TimeUnit unit)
        Description copied from interface: EventExecutorGroup
        Signals this executor that the caller wants the executor to be shut down. Once this method is called, EventExecutorGroup.isShuttingDown() starts to return true, and the executor prepares to shut itself down. Unlike EventExecutorGroup.shutdown(), graceful shutdown ensures that no tasks are submitted for 'the quiet period' (usually a couple seconds) before it shuts itself down. If a task is submitted during the quiet period, it is guaranteed to be accepted and the quiet period will start over.
        Specified by:
        shutdownGracefully in interface EventExecutorGroup
        Parameters:
        quietPeriod - the quiet period as described in the documentation
        timeout - the maximum amount of time to wait until the executor is EventExecutorGroup.shutdown() regardless if a task was submitted during the quiet period
        unit - the unit of quietPeriod and timeout
        Returns:
        the EventExecutorGroup.terminationFuture()

      • isShutdown

        public boolean isShutdown()
        Specified by:
        isShutdown in interface java.util.concurrent.ExecutorService

      • isTerminated

        public boolean isTerminated()
        Specified by:
        isTerminated in interface java.util.concurrent.ExecutorService

      • awaitTermination

        public boolean awaitTermination​(long timeout,
                                java.util.concurrent.TimeUnit unit)
                         throws java.lang.InterruptedException
        Specified by:
        awaitTermination in interface java.util.concurrent.ExecutorService
        Throws:
        java.lang.InterruptedException

      • execute

        public void execute​(java.lang.Runnable command)
        Specified by:
        execute in interface java.util.concurrent.Executor

      • invokeAny

        public <T> T invokeAny​(java.util.Collection<? extends java.util.concurrent.Callable<T>> tasks)
                throws java.lang.InterruptedException,
                       java.util.concurrent.ExecutionException
        Specified by:
        invokeAny in interface java.util.concurrent.ExecutorService
        Overrides:
        invokeAny in class java.util.concurrent.AbstractExecutorService
        Throws:
        java.lang.InterruptedException
        java.util.concurrent.ExecutionException

      • invokeAny

        public <T> T invokeAny​(java.util.Collection<? extends java.util.concurrent.Callable<T>> tasks,
                       long timeout,
                       java.util.concurrent.TimeUnit unit)
                throws java.lang.InterruptedException,
                       java.util.concurrent.ExecutionException,
                       java.util.concurrent.TimeoutException
        Specified by:
        invokeAny in interface java.util.concurrent.ExecutorService
        Overrides:
        invokeAny in class java.util.concurrent.AbstractExecutorService
        Throws:
        java.lang.InterruptedException
        java.util.concurrent.ExecutionException
        java.util.concurrent.TimeoutException

      • invokeAll

        public <T> java.util.List<java.util.concurrent.Future<T>> invokeAll​(java.util.Collection<? extends java.util.concurrent.Callable<T>> tasks)
                                                             throws java.lang.InterruptedException
        Specified by:
        invokeAll in interface java.util.concurrent.ExecutorService
        Overrides:
        invokeAll in class java.util.concurrent.AbstractExecutorService
        Throws:
        java.lang.InterruptedException

      • invokeAll

        public <T> java.util.List<java.util.concurrent.Future<T>> invokeAll​(java.util.Collection<? extends java.util.concurrent.Callable<T>> tasks,
                                                                    long timeout,
                                                                    java.util.concurrent.TimeUnit unit)
                                                             throws java.lang.InterruptedException
        Specified by:
        invokeAll in interface java.util.concurrent.ExecutorService
        Overrides:
        invokeAll in class java.util.concurrent.AbstractExecutorService
        Throws:
        java.lang.InterruptedException