Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.camel.spi;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ScheduledExecutorService;
import org.apache.camel.ShutdownableService;
import org.apache.camel.StaticService;
/**
* Strategy to create thread pools.
*
* This manager is pluggable so you can plugin a custom provider, for example if you want to leverage the WorkManager
* for a JEE server.
*
* You may want to just implement a custom {@link ThreadPoolFactory} and rely on the
* {@link org.apache.camel.impl.DefaultExecutorServiceManager}, if that is sufficient. The {@link ThreadPoolFactory} is
* always used for creating the actual thread pools. You can implement a custom {@link ThreadPoolFactory} to leverage
* the WorkManager for a JEE server.
*
* The {@link ThreadPoolFactory} has pure JDK API, where as this {@link ExecutorServiceManager} has Camel API concepts
* such as {@link ThreadPoolProfile}. Therefore it may be easier to only implement a custom {@link ThreadPoolFactory}.
*
* This manager has fine grained methods for creating various thread pools, however custom strategies do not have to
* exactly create those kind of pools. Feel free to return a shared or different kind of pool.
*
* If you use the newXXX methods to create thread pools, then Camel will by default take care of shutting down
* those created pools when {@link org.apache.camel.CamelContext} is shutting down.
*
* For more information about shutting down thread pools see the {@link #shutdown(java.util.concurrent.ExecutorService)}
* and {@link #shutdownNow(java.util.concurrent.ExecutorService)}, and {@link #getShutdownAwaitTermination()} methods.
* Notice the details about using a graceful shutdown at first, and then falling back to aggressive shutdown in case of
* await termination timeout occurred.
*
* @see ThreadPoolFactory
*/
public interface ExecutorServiceManager extends ShutdownableService, StaticService {
/**
* Gets the {@link ThreadPoolFactory} to use for creating the thread pools.
*
* @return the thread pool factory
*/
ThreadPoolFactory getThreadPoolFactory();
/**
* Sets a custom {@link ThreadPoolFactory} to use
*
* @param threadPoolFactory the thread pool factory
*/
void setThreadPoolFactory(ThreadPoolFactory threadPoolFactory);
/**
* Creates a full thread name
*
* @param name name which is appended to the full thread name
* @return the full thread name
*/
String resolveThreadName(String name);
/**
* Gets the thread pool profile by the given id
*
* @param id id of the thread pool profile to get
* @return the found profile, or null if not found
*/
ThreadPoolProfile getThreadPoolProfile(String id);
/**
* Registers the given thread pool profile
*
* @param profile the profile
*/
void registerThreadPoolProfile(ThreadPoolProfile profile);
/**
* Sets the default thread pool profile
*
* @param defaultThreadPoolProfile the new default thread pool profile
*/
void setDefaultThreadPoolProfile(ThreadPoolProfile defaultThreadPoolProfile);
/**
* Gets the default thread pool profile
*
* @return the default profile which are newer null
*/
ThreadPoolProfile getDefaultThreadPoolProfile();
/**
* 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 {@link org.apache.camel.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.
*
* @param pattern the pattern
* @throws IllegalArgumentException if the pattern is invalid.
*/
void setThreadNamePattern(String pattern) throws IllegalArgumentException;
/**
* Gets the thread name pattern to use
*
* @return the pattern
*/
String getThreadNamePattern();
/**
* Sets the time to wait for thread pools to shutdown orderly, when invoking the {@link #shutdown()} method.
*
* The default value is 10000 millis.
*
* @param timeInMillis time in millis.
*/
void setShutdownAwaitTermination(long timeInMillis);
/**
* Gets the time to wait for thread pools to shutdown orderly, when invoking the {@link #shutdown()} method.
*
* The default value is 10000 millis.
*
* @return the timeout value
*/
long getShutdownAwaitTermination();
/**
* Creates a new daemon thread with the given name.
*
* @param name name which is appended to the thread name
* @param runnable a runnable to be executed by new thread instance
* @return the created thread
*/
Thread newThread(String name, Runnable runnable);
/**
* Creates a new thread pool using the default thread pool profile.
*
* @param source the source object, usually it should be this passed in as parameter
* @param name name which is appended to the thread name
* @return the created thread pool
*/
ExecutorService newDefaultThreadPool(Object source, String name);
/**
* Creates a new scheduled thread pool using the default thread pool profile.
*
* @param source the source object, usually it should be this passed in as parameter
* @param name name which is appended to the thread name
* @return the created thread pool
*/
ScheduledExecutorService newDefaultScheduledThreadPool(Object source, String name);
/**
* Creates a new thread pool using the given profile
*
* @param source the source object, usually it should be this passed in as parameter
* @param name name which is appended to the thread name
* @param profile the profile with the thread pool settings to use
* @return the created thread pool
*/
ExecutorService newThreadPool(Object source, String name, ThreadPoolProfile profile);
/**
* Creates a new thread pool using using the given profile id
*
* @param source the source object, usually it should be this passed in as parameter
* @param name name which is appended to the thread name
* @param profileId the id of the profile with the thread pool settings to use
* @return the created thread pool, or null if the thread pool profile could not be found
*/
ExecutorService newThreadPool(Object source, String name, String profileId);
/**
* 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.
*
* @param source the source object, usually it should be this passed in as parameter
* @param name name which is appended to the thread name
* @param poolSize the core pool size
* @param maxPoolSize the maximum pool size
* @return the created thread pool
*/
ExecutorService newThreadPool(Object source, String name, int poolSize, int maxPoolSize);
/**
* 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.
*
* @param source the source object, usually it should be this passed in as parameter
* @param name name which is appended to the thread name
* @return the created thread pool
*/
ExecutorService newSingleThreadExecutor(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.
*
* @param source the source object, usually it should be this passed in as parameter
* @param name name which is appended to the thread name
* @return the created thread pool
*/
ExecutorService newCachedThreadPool(Object source, String name);
/**
* Creates a new fixed thread pool (the pool will not grow or shrink but has a fixed number of threads constantly).
*
* @param source the source object, usually it should be this passed in as parameter
* @param name name which is appended to the thread name
* @param poolSize the core pool size
* @return the created thread pool
*/
ExecutorService newFixedThreadPool(Object source, String name, int poolSize);
/**
* Creates a new scheduled thread pool.
*
* @param source the source object, usually it should be this passed in as parameter
* @param name name which is appended to the thread name
* @param poolSize the core pool size
* @return the created thread pool
*/
ScheduledExecutorService newScheduledThreadPool(Object source, String name, int poolSize);
/**
* Creates a new single-threaded thread pool. This is often used for background threads.
*
* @param source the source object, usually it should be this passed in as parameter
* @param name name which is appended to the thread name
* @return the created thread pool
*/
ScheduledExecutorService newSingleThreadScheduledExecutor(Object source, String name);
/**
* Creates a new scheduled thread pool using a profile
*
* @param source the source object, usually it should be this passed in as parameter
* @param name name which is appended to the thread name
* @param profile the profile with the thread pool settings to use
* @return created thread pool
*/
ScheduledExecutorService newScheduledThreadPool(Object source, String name, ThreadPoolProfile profile);
/**
* Creates a new scheduled thread pool using a profile id
*
* @param source the source object, usually it should be this passed in as parameter
* @param name name which is appended to the thread name
* @param profileId the id of the profile with the thread pool settings to use
* @return created thread pool
*/
ScheduledExecutorService newScheduledThreadPool(Object source, String name, String profileId);
/**
* Shutdown the given executor service (not graceful).
*
* This implementation will issue a regular shutdown of the executor service, ie calling
* {@link java.util.concurrent.ExecutorService#shutdown()} and return.
*
* @param executorService the executor service to shutdown
* @see java.util.concurrent.ExecutorService#shutdown()
*/
void shutdown(ExecutorService executorService);
/**
* 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 {@link #shutdownNow(java.util.concurrent.ExecutorService)} which forces a shutdown. The
* {@link #getShutdownAwaitTermination()} is used as timeout value waiting for orderly shutdown to complete
* normally, before going aggressively.
*
* @param executorService the executor service to shutdown
* @see java.util.concurrent.ExecutorService#shutdown()
* @see #getShutdownAwaitTermination()
*/
void shutdownGraceful(ExecutorService executorService);
/**
* 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 {@link #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.
*
* @param executorService the executor service to shutdown
* @param shutdownAwaitTermination timeout in millis to wait for orderly shutdown
* @see java.util.concurrent.ExecutorService#shutdown()
*/
void shutdownGraceful(ExecutorService executorService, long shutdownAwaitTermination);
/**
* Shutdown now the given executor service aggressively.
*
* This implementation will issues a regular shutdownNow of the executor service, ie calling
* {@link java.util.concurrent.ExecutorService#shutdownNow()} and return.
*
* @param executorService the executor service to shutdown now
* @return list of tasks that never commenced execution
* @see java.util.concurrent.ExecutorService#shutdownNow()
*/
List shutdownNow(ExecutorService executorService);
/**
* 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.
*
* @param executorService the thread pool
* @param shutdownAwaitTermination time in millis to use as timeout
* @return true if the pool is terminated, or false if we timed out
* @throws InterruptedException is thrown if we are interrupted during waiting
*/
boolean awaitTermination(ExecutorService executorService, long shutdownAwaitTermination) throws InterruptedException;
}
