BasicThreadFactory (ph-commons 9.3.3 API)

java.lang.Object
- com.helger.commons.concurrent.BasicThreadFactory

All Implemented Interfaces:

ThreadFactory
```
public class BasicThreadFactory
extends Object
implements ThreadFactory
```
An implementation of the 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 %d which will be replaced by the number of the current thread (ThreadFactoryImpl keeps 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 java.lang.Thread class defines constants for valid ranges of priority values.
- The UncaughtExceptionHandler for 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 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 ().setNamingPattern ("workerthread-%d")
                                                               .setDaemon (true)
                                                               .setPriority (Thread.MAX_PRIORITY)
                                                               .build ();
 // Create an executor service for single-threaded execution
 ExecutorService exec = Executors.newSingleThreadExecutor (factory);
 
```
Since:

8.5.3

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class BasicThreadFactory.Builder
A builder class for creating instances of BasicThreadFactory.

Nested Classes
Modifier and Type	Class and Description
`static class`	`BasicThreadFactory.Builder` A builder class for creating instances of `BasicThreadFactory`.

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`BasicThreadFactory(BasicThreadFactory.Builder aBuilder)` Creates a new instance of `ThreadFactoryImpl` and configures it from the specified `Builder` object.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`ETriState`	`getDaemon()` Returns the daemon flag.
`static Thread.UncaughtExceptionHandler`	`getDefaultUncaughtExceptionHandler()`
`String`	`getNamingPattern()` Returns the naming pattern for naming newly created threads.
`Integer`	`getPriority()` Returns the priority of the threads created by this factory.
`long`	`getThreadCount()` Returns the number of threads this factory has already created.
`Thread.UncaughtExceptionHandler`	`getUncaughtExceptionHandler()` Returns the `UncaughtExceptionHandler` for the threads created by this factory.
`ThreadFactory`	`getWrappedFactory()` Returns the wrapped `ThreadFactory`.
`protected void`	`initializeThread(Thread aThread)` Initializes the specified thread.
`Thread`	`newThread(Runnable aRunnable)` Creates a new thread.
`static void`	`setDefaultUncaughtExceptionHandler(Thread.UncaughtExceptionHandler aHdl)` Set the default uncaught exception handler for future instances of BasicThreadFactory.
`String`	`toString()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - BasicThreadFactory
```
protected BasicThreadFactory(@Nonnull
                             BasicThreadFactory.Builder aBuilder)
```
    Creates a new instance of ThreadFactoryImpl and configures it from the specified Builder object.
    
    Parameters:
    
    aBuilder - the Builder object
- Method Detail
  - setDefaultUncaughtExceptionHandler
```
public static void setDefaultUncaughtExceptionHandler(@Nonnull
                                                      Thread.UncaughtExceptionHandler aHdl)
```
    Set the default uncaught exception handler for future instances of BasicThreadFactory. By default a logging exception handler is present.
    
    Parameters:
    
    aHdl - The handlers to be used. May not be null.
    
    Since:
    
    9.0.0
  - getDefaultUncaughtExceptionHandler
```
@Nonnull
public static Thread.UncaughtExceptionHandler getDefaultUncaughtExceptionHandler()
```
    Returns:
    
    The default uncaught exception handler used. Never null.
  - getWrappedFactory
```
@Nonnull
public final ThreadFactory getWrappedFactory()
```
    Returns the wrapped ThreadFactory. This factory is used for actually creating threads. This method never returns null. If no ThreadFactory was passed when this object was created, a default thread factory is returned.
    
    Returns:
    
    the wrapped ThreadFactory
  - getNamingPattern
```
@Nonnull
public final String getNamingPattern()
```
    Returns the naming pattern for naming newly created threads. Result can be null if no naming pattern was provided.
    
    Returns:
    
    the naming pattern
  - getDaemon
```
@Nonnull
public final ETriState getDaemon()
```
    Returns the daemon flag. This flag determines whether newly created threads should be daemon threads. If true, this factory object calls setDaemon(true) on the newly created threads. Result can be null if no daemon flag was provided at creation time.
    
    Returns:
    
    the daemon flag
  - getPriority
```
@Nullable
public final Integer getPriority()
```
    Returns the priority of the threads created by this factory. Result can be null if no priority was specified.
    
    Returns:
    
    the priority for newly created threads
  - getUncaughtExceptionHandler
```
public final Thread.UncaughtExceptionHandler getUncaughtExceptionHandler()
```
    Returns the UncaughtExceptionHandler for the threads created by this factory. Result can be null if no handler was provided.
    
    Returns:
    
    the UncaughtExceptionHandler
  - getThreadCount
```
@Nonnull
public long getThreadCount()
```
    Returns the number of threads this factory has already created. This class maintains an internal counter that is incremented each time the newThread(Runnable) method is invoked.
    
    Returns:
    
    the number of threads created by this factory
  - initializeThread
```
@OverrideOnDemand
protected void initializeThread(@Nonnull
                                                   Thread aThread)
```
    Initializes the specified thread. This method is called by newThread(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:
    
    aThread - the thread to be initialized
  - newThread
```
@Nonnull
public Thread newThread(@Nonnull
                                  Runnable aRunnable)
```
    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:
    
    newThread in interface ThreadFactory
    
    Parameters:
    
    aRunnable - the Runnable to be executed by the new thread
    
    Returns:
    
    the newly created thread
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class BasicThreadFactory

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

BasicThreadFactory

Method Detail

setDefaultUncaughtExceptionHandler

getDefaultUncaughtExceptionHandler

getWrappedFactory

getNamingPattern

getDaemon

getPriority

getUncaughtExceptionHandler

getThreadCount

initializeThread

newThread

toString