Class PriorityThreadPoolExecutor

  • All Implemented Interfaces:
    java.util.concurrent.Executor, java.util.concurrent.ExecutorService

    public class PriorityThreadPoolExecutor
    extends java.util.concurrent.ThreadPoolExecutor
    A ThreadPoolExecutor that maintains the order of IoEvents within a session (similar to OrderedThreadPoolExecutor) and allows some sessions to be prioritized over other sessions.

    If you don't need to maintain the order of events per session, please use UnorderedThreadPoolExecutor.

    If you don't need to prioritize sessions, please use OrderedThreadPoolExecutor.

    Author:
    Apache MINA Project, Guus der Kinderen, guus.der.kinderen@gmail.com
    • Nested Class Summary

      • Nested classes/interfaces inherited from class java.util.concurrent.ThreadPoolExecutor

        java.util.concurrent.ThreadPoolExecutor.AbortPolicy, java.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy, java.util.concurrent.ThreadPoolExecutor.DiscardOldestPolicy, java.util.concurrent.ThreadPoolExecutor.DiscardPolicy
    • Constructor Summary

      Constructors 
      Constructor Description
      PriorityThreadPoolExecutor()
      Creates a default ThreadPool, with default values : - minimum pool size is 0 - maximum pool size is 16 - keepAlive set to 30 seconds - A default ThreadFactory - All events are accepted
      PriorityThreadPoolExecutor​(int maximumPoolSize)
      Creates a default ThreadPool, with default values : - minimum pool size is 0 - keepAlive set to 30 seconds - A default ThreadFactory - All events are accepted
      PriorityThreadPoolExecutor​(int corePoolSize, int maximumPoolSize)
      Creates a default ThreadPool, with default values : - keepAlive set to 30 seconds - A default ThreadFactory - All events are accepted
      PriorityThreadPoolExecutor​(int corePoolSize, int maximumPoolSize, long keepAliveTime, java.util.concurrent.TimeUnit unit)
      Creates a default ThreadPool, with default values : - A default ThreadFactory - All events are accepted
      PriorityThreadPoolExecutor​(int corePoolSize, int maximumPoolSize, long keepAliveTime, java.util.concurrent.TimeUnit unit, java.util.concurrent.ThreadFactory threadFactory)
      Creates a default ThreadPool, with default values : - A default ThreadFactory
      PriorityThreadPoolExecutor​(int corePoolSize, int maximumPoolSize, long keepAliveTime, java.util.concurrent.TimeUnit unit, java.util.concurrent.ThreadFactory threadFactory, IoEventQueueHandler eventQueueHandler, java.util.Comparator<IoSession> comparator)
      Creates a new instance of a PrioritisedOrderedThreadPoolExecutor.
      PriorityThreadPoolExecutor​(int corePoolSize, int maximumPoolSize, long keepAliveTime, java.util.concurrent.TimeUnit unit, IoEventQueueHandler eventQueueHandler)
      Creates a default ThreadPool, with default values : - A default ThreadFactory
      PriorityThreadPoolExecutor​(int maximumPoolSize, java.util.Comparator<IoSession> comparator)
      Creates a default ThreadPool, with default values : - minimum pool size is 0 - keepAlive set to 30 seconds - A default ThreadFactory - All events are accepted
      PriorityThreadPoolExecutor​(java.util.Comparator<IoSession> comparator)
      Creates a default ThreadPool, with default values : - minimum pool size is 0 - maximum pool size is 16 - keepAlive set to 30 seconds - A default ThreadFactory - All events are accepted
    • Constructor Detail

      • PriorityThreadPoolExecutor

        public PriorityThreadPoolExecutor()
        Creates a default ThreadPool, with default values : - minimum pool size is 0 - maximum pool size is 16 - keepAlive set to 30 seconds - A default ThreadFactory - All events are accepted
      • PriorityThreadPoolExecutor

        public PriorityThreadPoolExecutor​(java.util.Comparator<IoSession> comparator)
        Creates a default ThreadPool, with default values : - minimum pool size is 0 - maximum pool size is 16 - keepAlive set to 30 seconds - A default ThreadFactory - All events are accepted
      • PriorityThreadPoolExecutor

        public PriorityThreadPoolExecutor​(int maximumPoolSize)
        Creates a default ThreadPool, with default values : - minimum pool size is 0 - keepAlive set to 30 seconds - A default ThreadFactory - All events are accepted
        Parameters:
        maximumPoolSize - The maximum pool size
      • PriorityThreadPoolExecutor

        public PriorityThreadPoolExecutor​(int maximumPoolSize,
                                          java.util.Comparator<IoSession> comparator)
        Creates a default ThreadPool, with default values : - minimum pool size is 0 - keepAlive set to 30 seconds - A default ThreadFactory - All events are accepted
        Parameters:
        maximumPoolSize - The maximum pool size
      • PriorityThreadPoolExecutor

        public PriorityThreadPoolExecutor​(int corePoolSize,
                                          int maximumPoolSize)
        Creates a default ThreadPool, with default values : - keepAlive set to 30 seconds - A default ThreadFactory - All events are accepted
        Parameters:
        corePoolSize - The initial pool sizePoolSize
        maximumPoolSize - The maximum pool size
      • PriorityThreadPoolExecutor

        public PriorityThreadPoolExecutor​(int corePoolSize,
                                          int maximumPoolSize,
                                          long keepAliveTime,
                                          java.util.concurrent.TimeUnit unit)
        Creates a default ThreadPool, with default values : - A default ThreadFactory - All events are accepted
        Parameters:
        corePoolSize - The initial pool sizePoolSize
        maximumPoolSize - The maximum pool size
        keepAliveTime - Default duration for a thread
        unit - Time unit used for the keepAlive value
      • PriorityThreadPoolExecutor

        public PriorityThreadPoolExecutor​(int corePoolSize,
                                          int maximumPoolSize,
                                          long keepAliveTime,
                                          java.util.concurrent.TimeUnit unit,
                                          IoEventQueueHandler eventQueueHandler)
        Creates a default ThreadPool, with default values : - A default ThreadFactory
        Parameters:
        corePoolSize - The initial pool sizePoolSize
        maximumPoolSize - The maximum pool size
        keepAliveTime - Default duration for a thread
        unit - Time unit used for the keepAlive value
        eventQueueHandler - The queue used to store events
      • PriorityThreadPoolExecutor

        public PriorityThreadPoolExecutor​(int corePoolSize,
                                          int maximumPoolSize,
                                          long keepAliveTime,
                                          java.util.concurrent.TimeUnit unit,
                                          java.util.concurrent.ThreadFactory threadFactory)
        Creates a default ThreadPool, with default values : - A default ThreadFactory
        Parameters:
        corePoolSize - The initial pool sizePoolSize
        maximumPoolSize - The maximum pool size
        keepAliveTime - Default duration for a thread
        unit - Time unit used for the keepAlive value
        threadFactory - The factory used to create threads
      • PriorityThreadPoolExecutor

        public PriorityThreadPoolExecutor​(int corePoolSize,
                                          int maximumPoolSize,
                                          long keepAliveTime,
                                          java.util.concurrent.TimeUnit unit,
                                          java.util.concurrent.ThreadFactory threadFactory,
                                          IoEventQueueHandler eventQueueHandler,
                                          java.util.Comparator<IoSession> comparator)
        Creates a new instance of a PrioritisedOrderedThreadPoolExecutor.
        Parameters:
        corePoolSize - The initial pool sizePoolSize
        maximumPoolSize - The maximum pool size
        keepAliveTime - Default duration for a thread
        unit - Time unit used for the keepAlive value
        threadFactory - The factory used to create threads
        eventQueueHandler - The queue used to store events
    • Method Detail

      • getQueueHandler

        public IoEventQueueHandler getQueueHandler()
        Returns:
        The associated queue handler.
      • setRejectedExecutionHandler

        public void setRejectedExecutionHandler​(java.util.concurrent.RejectedExecutionHandler handler)
        Overrides:
        setRejectedExecutionHandler in class java.util.concurrent.ThreadPoolExecutor
      • setMaximumPoolSize

        public void setMaximumPoolSize​(int maximumPoolSize)
        Overrides:
        setMaximumPoolSize in class java.util.concurrent.ThreadPoolExecutor
      • awaitTermination

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

        public boolean isShutdown()
        Specified by:
        isShutdown in interface java.util.concurrent.ExecutorService
        Overrides:
        isShutdown in class java.util.concurrent.ThreadPoolExecutor
      • isTerminated

        public boolean isTerminated()
        Specified by:
        isTerminated in interface java.util.concurrent.ExecutorService
        Overrides:
        isTerminated in class java.util.concurrent.ThreadPoolExecutor
      • shutdown

        public void shutdown()
        Specified by:
        shutdown in interface java.util.concurrent.ExecutorService
        Overrides:
        shutdown in class java.util.concurrent.ThreadPoolExecutor
      • shutdownNow

        public java.util.List<java.lang.Runnable> shutdownNow()
        Specified by:
        shutdownNow in interface java.util.concurrent.ExecutorService
        Overrides:
        shutdownNow in class java.util.concurrent.ThreadPoolExecutor
      • execute

        public void execute​(java.lang.Runnable task)
        Specified by:
        execute in interface java.util.concurrent.Executor
        Overrides:
        execute in class java.util.concurrent.ThreadPoolExecutor
      • getActiveCount

        public int getActiveCount()
        Overrides:
        getActiveCount in class java.util.concurrent.ThreadPoolExecutor
      • getCompletedTaskCount

        public long getCompletedTaskCount()
        Overrides:
        getCompletedTaskCount in class java.util.concurrent.ThreadPoolExecutor
      • getLargestPoolSize

        public int getLargestPoolSize()
        Overrides:
        getLargestPoolSize in class java.util.concurrent.ThreadPoolExecutor
      • getPoolSize

        public int getPoolSize()
        Overrides:
        getPoolSize in class java.util.concurrent.ThreadPoolExecutor
      • getTaskCount

        public long getTaskCount()
        Overrides:
        getTaskCount in class java.util.concurrent.ThreadPoolExecutor
      • isTerminating

        public boolean isTerminating()
        Overrides:
        isTerminating in class java.util.concurrent.ThreadPoolExecutor
      • prestartAllCoreThreads

        public int prestartAllCoreThreads()
        Overrides:
        prestartAllCoreThreads in class java.util.concurrent.ThreadPoolExecutor
      • prestartCoreThread

        public boolean prestartCoreThread()
        Overrides:
        prestartCoreThread in class java.util.concurrent.ThreadPoolExecutor
      • getQueue

        public java.util.concurrent.BlockingQueue<java.lang.Runnable> getQueue()
        Overrides:
        getQueue in class java.util.concurrent.ThreadPoolExecutor
      • purge

        public void purge()
        Overrides:
        purge in class java.util.concurrent.ThreadPoolExecutor
      • remove

        public boolean remove​(java.lang.Runnable task)
        Overrides:
        remove in class java.util.concurrent.ThreadPoolExecutor
      • setCorePoolSize

        public void setCorePoolSize​(int corePoolSize)
        Overrides:
        setCorePoolSize in class java.util.concurrent.ThreadPoolExecutor