Package org.apache.camel.spi

Interface ExecutorServiceManager

    • Method Detail

      • setThreadPoolFactory

        void setThreadPoolFactory​(ThreadPoolFactory threadPoolFactory)
        Sets a custom ThreadPoolFactory to use
        Parameters:
        threadPoolFactory - the thread pool factory

      • resolveThreadName

        String resolveThreadName​(String name)
        Creates a full thread name
        Parameters:
        name - name which is appended to the full thread name
        Returns:
        the full thread name

      • getThreadPoolProfile

        ThreadPoolProfile getThreadPoolProfile​(String id)
        Gets the thread pool profile by the given id
        Parameters:
        id - id of the thread pool profile to get
        Returns:
        the found profile, or null if not found

      • registerThreadPoolProfile

        void registerThreadPoolProfile​(ThreadPoolProfile profile)
        Registers the given thread pool profile
        Parameters:
        profile - the profile

      • setDefaultThreadPoolProfile

        void setDefaultThreadPoolProfile​(ThreadPoolProfile defaultThreadPoolProfile)
        Sets the default thread pool profile
        Parameters:
        defaultThreadPoolProfile - the new default thread pool profile

      • getDefaultThreadPoolProfile

        ThreadPoolProfile getDefaultThreadPoolProfile()
        Gets the default thread pool profile
        Returns:
        the default profile which are newer null

      • setThreadNamePattern

        void setThreadNamePattern​(String pattern)
                   throws IllegalArgumentException
        Sets the thread name pattern used for creating the full thread name.

        The default pattern is: Camel (#camelId#) thread ##counter# - #name#

        Where #camelId# is the name of the CamelContext
        and #counter# is a unique incrementing counter.
        and #name# is the regular thread name.
        You can also use #longName# is the long thread name which can include endpoint parameters etc.

        Parameters:
        pattern - the pattern
        Throws:
        IllegalArgumentException - if the pattern is invalid.

      • getThreadNamePattern

        String getThreadNamePattern()
        Gets the thread name pattern to use
        Returns:
        the pattern

      • setShutdownAwaitTermination

        void setShutdownAwaitTermination​(long timeInMillis)
        Sets the time to wait for thread pools to shutdown orderly, when invoking the ShutdownableService.shutdown() method.

        The default value is 10000 millis.

        Parameters:
        timeInMillis - time in millis.

      • getShutdownAwaitTermination

        long getShutdownAwaitTermination()
        Gets the time to wait for thread pools to shutdown orderly, when invoking the ShutdownableService.shutdown() method.

        The default value is 10000 millis.

        Returns:
        the timeout value

      • newThread

        Thread newThread​(String name,
                 Runnable runnable)
        Creates a new daemon thread with the given name.
        Parameters:
        name - name which is appended to the thread name
        runnable - a runnable to be executed by new thread instance
        Returns:
        the created thread

      • newDefaultThreadPool

        ExecutorService newDefaultThreadPool​(Object source,
                                     String name)
        Creates a new thread pool using the default thread pool profile.
        Parameters:
        source - the source object, usually it should be this passed in as parameter
        name - name which is appended to the thread name
        Returns:
        the created thread pool

      • newDefaultScheduledThreadPool

        ScheduledExecutorService newDefaultScheduledThreadPool​(Object source,
                                                       String name)
        Creates a new scheduled thread pool using the default thread pool profile.
        Parameters:
        source - the source object, usually it should be this passed in as parameter
        name - name which is appended to the thread name
        Returns:
        the created thread pool

      • newThreadPool

        ExecutorService newThreadPool​(Object source,
                              String name,
                              ThreadPoolProfile profile)
        Creates a new thread pool using the given profile
        Parameters:
        source - the source object, usually it should be this passed in as parameter
        name - name which is appended to the thread name
        profile - the profile with the thread pool settings to use
        Returns:
        the created thread pool

      • newThreadPool

        ExecutorService newThreadPool​(Object source,
                              String name,
                              String profileId)
        Creates a new thread pool using using the given profile id
        Parameters:
        source - the source object, usually it should be this passed in as parameter
        name - name which is appended to the thread name
        profileId - the id of the profile with the thread pool settings to use
        Returns:
        the created thread pool, or null if the thread pool profile could not be found

      • newThreadPool

        ExecutorService newThreadPool​(Object source,
                              String name,
                              int poolSize,
                              int maxPoolSize)
        Creates a new thread pool.

        Will fallback and use values from the default thread pool profile for keep alive time, rejection policy and other parameters which cannot be specified.

        Parameters:
        source - the source object, usually it should be this passed in as parameter
        name - name which is appended to the thread name
        poolSize - the core pool size
        maxPoolSize - the maximum pool size
        Returns:
        the created thread pool

      • newSingleThreadExecutor

        ExecutorService newSingleThreadExecutor​(Object source,
                                        String name)
        Creates a new single-threaded thread pool. This is often used for background threads.

        Notice that there will always be a single thread in the pool. If you want the pool to be able to shrink to no threads, then use the newThreadPool method, and use 0 in core pool size, and 1 in max pool size.

        Parameters:
        source - the source object, usually it should be this passed in as parameter
        name - name which is appended to the thread name
        Returns:
        the created thread pool

      • newCachedThreadPool

        ExecutorService newCachedThreadPool​(Object source,
                                    String name)
        Creates a new cached thread pool.

        Important: Using cached thread pool should be used by care as they have no upper bound on created threads, and have no task backlog, and can therefore overload the JVM.

        Parameters:
        source - the source object, usually it should be this passed in as parameter
        name - name which is appended to the thread name
        Returns:
        the created thread pool

      • newFixedThreadPool

        ExecutorService newFixedThreadPool​(Object source,
                                   String name,
                                   int poolSize)
        Creates a new fixed thread pool (the pool will not grow or shrink but has a fixed number of threads constantly).
        Parameters:
        source - the source object, usually it should be this passed in as parameter
        name - name which is appended to the thread name
        poolSize - the core pool size
        Returns:
        the created thread pool

      • newScheduledThreadPool

        ScheduledExecutorService newScheduledThreadPool​(Object source,
                                                String name,
                                                int poolSize)
        Creates a new scheduled thread pool.
        Parameters:
        source - the source object, usually it should be this passed in as parameter
        name - name which is appended to the thread name
        poolSize - the core pool size
        Returns:
        the created thread pool

      • newSingleThreadScheduledExecutor

        ScheduledExecutorService newSingleThreadScheduledExecutor​(Object source,
                                                          String name)
        Creates a new single-threaded thread pool. This is often used for background threads.
        Parameters:
        source - the source object, usually it should be this passed in as parameter
        name - name which is appended to the thread name
        Returns:
        the created thread pool

      • newScheduledThreadPool

        ScheduledExecutorService newScheduledThreadPool​(Object source,
                                                String name,
                                                ThreadPoolProfile profile)
        Creates a new scheduled thread pool using a profile
        Parameters:
        source - the source object, usually it should be this passed in as parameter
        name - name which is appended to the thread name
        profile - the profile with the thread pool settings to use
        Returns:
        created thread pool

      • newScheduledThreadPool

        ScheduledExecutorService newScheduledThreadPool​(Object source,
                                                String name,
                                                String profileId)
        Creates a new scheduled thread pool using a profile id
        Parameters:
        source - the source object, usually it should be this passed in as parameter
        name - name which is appended to the thread name
        profileId - the id of the profile with the thread pool settings to use
        Returns:
        created thread pool

      • shutdown

        void shutdown​(ExecutorService executorService)
        Shutdown the given executor service (not graceful).

        This implementation will issue a regular shutdown of the executor service, ie calling ExecutorService.shutdown() and return.

        Parameters:
        executorService - the executor service to shutdown
        See Also:
        ExecutorService.shutdown()

      • shutdownGraceful

        void shutdownGraceful​(ExecutorService executorService,
                      long shutdownAwaitTermination)
        Shutdown the given executor service graceful at first, and then aggressively if the await termination timeout was hit.

        Will try to perform an orderly shutdown by giving the running threads time to complete tasks, before going more aggressively by doing a shutdownNow(java.util.concurrent.ExecutorService) which forces a shutdown. The parameter shutdownAwaitTermination is used as timeout value waiting for orderly shutdown to complete normally, before going aggressively.

        Parameters:
        executorService - the executor service to shutdown
        shutdownAwaitTermination - timeout in millis to wait for orderly shutdown
        See Also:
        ExecutorService.shutdown()

      • shutdownNow

        List<Runnable> shutdownNow​(ExecutorService executorService)
        Shutdown now the given executor service aggressively.

        This implementation will issues a regular shutdownNow of the executor service, ie calling ExecutorService.shutdownNow() and return.

        Parameters:
        executorService - the executor service to shutdown now
        Returns:
        list of tasks that never commenced execution
        See Also:
        ExecutorService.shutdownNow()

      • awaitTermination

        boolean awaitTermination​(ExecutorService executorService,
                         long shutdownAwaitTermination)
                  throws InterruptedException
        Awaits the termination of the thread pool.

        This implementation will log every 2nd second at INFO level that we are waiting, so the end user can see we are not hanging in case it takes longer time to terminate the pool.

        Parameters:
        executorService - the thread pool
        shutdownAwaitTermination - time in millis to use as timeout
        Returns:
        true if the pool is terminated, or false if we timed out
        Throws:
        InterruptedException - is thrown if we are interrupted during waiting