Class BasicThreadFactory
- All Implemented Interfaces:
ThreadFactory
ThreadFactory interface that provides some
configuration options for the threads it creates.
A ThreadFactory is used for instance by an ExecutorService to
create the threads it uses for executing tasks. In many cases users do not
have to care about a ThreadFactory because the default one used by an
ExecutorService will do. However, if there are special requirements
for the threads, a custom ThreadFactory has to be created.
This class provides some frequently needed configuration options for the threads it creates. These are the following:
- A name pattern for the threads created by this factory can be specified.
This is often useful if an application uses multiple executor services for
different purposes. If the names of the threads used by these services have
meaningful names, log output or exception traces can be much easier to read.
Naming patterns are format strings as used by the
String.format()method. The string can contain the place holder%dwhich will be replaced by the number of the current thread (ThreadFactoryImplkeeps a counter of the threads it has already created). For instance, the naming pattern"My %d. worker thread"will result in thread names like"My 1. worker thread","My 2. worker thread"and so on. - A flag whether the threads created by this factory should be daemon threads. This can impact the exit behavior of the current Java application because the JVM shuts down if there are only daemon threads running.
- The priority of the thread. Here an integer value can be provided. The
Threadclass defines constants for valid ranges of priority values. - The
Thread.UncaughtExceptionHandlerfor the thread. This handler is called if an uncaught exception occurs within the thread.
BasicThreadFactory wraps another thread factory which actually
creates new threads. The configuration options are set on the threads created
by the wrapped thread factory. On construction time the factory to be wrapped
can be specified. If none is provided, a default ThreadFactory is
used.
Instances of BasicThreadFactory are not created directly, but the
nested BasicThreadFactory.Builder class is used for this purpose. Using the builder only
the configuration options an application is interested in need to be set. The
following example shows how a BasicThreadFactory is created and
installed in an ExecutorService:
// Create a factory that produces daemon threads with a naming pattern and
// a priority
BasicThreadFactory factory = new BasicThreadFactory.Builder()
.namingPattern("workerthread-%d")
.daemon(true)
.priority(Thread.MAX_PRIORITY)
.build();
// Create an executor service for single-threaded execution
ExecutorService exec = Executors.newSingleThreadExecutor(factory);
- Since:
- 3.0
-
Nested Class Summary
Nested ClassesModifier and TypeClassDescriptionstatic classA builder class for creating instances ofBasicThreadFactory. -
Field Summary
FieldsModifier and TypeFieldDescriptionprivate final BooleanStores the daemon status flag.private final StringThe naming pattern for newly created threads.private final IntegerStores the priority.private final AtomicLongA counter for the threads created by this factory.private final Thread.UncaughtExceptionHandlerThe uncaught exception handler.private final ThreadFactoryThe wrapped factory. -
Constructor Summary
ConstructorsModifierConstructorDescriptionprivateCreates a new instance ofThreadFactoryand configures it from the specifiedBasicThreadFactory.Builderobject. -
Method Summary
Modifier and TypeMethodDescriptionstatic BasicThreadFactory.Builderbuilder()Creates a new builder.final BooleanGets the daemon flag.final StringGets the naming pattern for naming newly created threads.final IntegerGets the priority of the threads created by this factory.longGets the number of threads this factory has already created.Gets theThread.UncaughtExceptionHandlerfor the threads created by this factory.final ThreadFactoryGets the wrappedThreadFactory.private voidinitializeThread(Thread thread) Initializes the specified thread.Creates a new thread.
-
Field Details
-
threadCounter
A counter for the threads created by this factory. -
wrappedFactory
The wrapped factory. -
uncaughtExceptionHandler
The uncaught exception handler. -
namingPattern
The naming pattern for newly created threads.The naming pattern is a
format stringthat expects a single argument. This argument is the number of the thread to be created. For instance, if the naming pattern is"MyThread-%d", the first thread created by this factory will be named"MyThread-1", the second one"MyThread-2"and so on. -
priority
Stores the priority. -
daemon
Stores the daemon status flag.
-
-
Constructor Details
-
BasicThreadFactory
Creates a new instance ofThreadFactoryand configures it from the specifiedBasicThreadFactory.Builderobject.- Parameters:
builder- TheBasicThreadFactory.Builderobject
-
-
Method Details
-
builder
Creates a new builder.- Returns:
- A new builder.
- Since:
- 3.18.0
-
getDaemonFlag
Gets the daemon flag. This flag determines whether newly created threads should be daemon threads. If true, this factory object callssetDaemon(true)on the newly created threads. Result can benullif no daemon flag was provided at creation time.- Returns:
- The daemon flag.
-
getNamingPattern
Gets the naming pattern for naming newly created threads. Result can benullif no naming pattern was provided.The naming pattern is a
format stringthat expects a single argument. This argument is the number of the thread to be created. For instance, if the naming pattern is"MyThread-%d", the first thread created by this factory will be named"MyThread-1", the second one"MyThread-2"and so on.- Returns:
- The naming pattern.
-
getPriority
Gets the priority of the threads created by this factory. Result can benullif no priority was specified.- Returns:
- The priority for newly created threads.
-
getThreadCount
public long getThreadCount()Gets the number of threads this factory has already created. This class maintains an internal counter that is incremented each time thenewThread(Runnable)method is invoked.- Returns:
- The number of threads created by this factory.
-
getUncaughtExceptionHandler
Gets theThread.UncaughtExceptionHandlerfor the threads created by this factory. Result can benullif no handler was provided.- Returns:
- The
Thread.UncaughtExceptionHandler.
-
getWrappedFactory
Gets the wrappedThreadFactory. This factory is used for actually creating threads. This method never returnsnull. If noThreadFactorywas passed when this object was created, a default thread factory is returned.- Returns:
- The wrapped
ThreadFactory.
-
initializeThread
Initializes the specified thread. This method is called bynewThread(Runnable)after a new thread has been obtained from the wrapped thread factory. It initializes the thread according to the options set for this factory.- Parameters:
thread- The thread to be initialized.
-
newThread
Creates a new thread. This implementation delegates to the wrapped factory for creating the thread. Then, on the newly created thread the corresponding configuration options are set.- Specified by:
newThreadin interfaceThreadFactory- Parameters:
runnable- TheRunnableto be executed by the new thread.- Returns:
- The newly created thread.
-