T - the type of the object managed by this initializer classpublic abstract class BackgroundInitializer<T> extends Object implements ConcurrentInitializer<T>
A class that allows complex initialization operations in a background task.
Applications often have to do some expensive initialization steps when they are started, e.g. constructing a connection to a database, reading a configuration file, etc. Doing these things in parallel can enhance performance as the CPU load can be improved. However, when access to the resources initialized in a background thread is actually required, synchronization has to be performed to ensure that their initialization is complete.
 This abstract base class provides support for this use case. A concrete
 subclass must implement the initialize() method. Here an arbitrary
 initialization can be implemented, and a result object can be returned. With
 this method in place the basic usage of this class is as follows (where
 MyBackgroundInitializer is a concrete subclass):
 
MyBackgroundInitializer initializer = new MyBackgroundInitializer(); initializer.start(); // Now do some other things. Initialization runs in a parallel thread ... // Wait for the end of initialization and access the result object Object result = initializer.get();
 After the construction of a BackgroundInitializer object its
 start() method has to be called. This starts the background
 processing. The application can now continue to do other things. When it
 needs access to the object produced by the BackgroundInitializer it
 calls its get() method. If initialization is already complete,
 get() returns the result object immediately. Otherwise it blocks
 until the result object is fully constructed.
 
 BackgroundInitializer is a thin wrapper around a Future
 object and uses an ExecutorService for running the background
 initialization task. It is possible to pass in an ExecutorService at
 construction time or set one using setExternalExecutor() before
 start() was called. Then this object is used to spawn the background
 task. If no ExecutorService has been provided, BackgroundInitializer creates a temporary ExecutorService and
 destroys it when initialization is complete.
 
 The methods provided by BackgroundInitializer provide for minimal
 interaction with the wrapped Future object. It is also possible to
 obtain the Future object directly. Then the enhanced functionality
 offered by Future can be used, e.g. to check whether the background
 operation is complete or to cancel the operation.
 
| Modifier | Constructor and Description | 
|---|---|
| protected  | BackgroundInitializer()Creates a new instance of  BackgroundInitializer. | 
| protected  | BackgroundInitializer(ExecutorService exec)Creates a new instance of  BackgroundInitializerand initializes
 it with the givenExecutorService. | 
| Modifier and Type | Method and Description | 
|---|---|
| T | get()Returns the result of the background initialization. | 
| protected ExecutorService | getActiveExecutor()Returns the  ExecutorServicethat is actually used for executing
 the background task. | 
| ExecutorService | getExternalExecutor()Returns the external  ExecutorServiceto be used by this class. | 
| Future<T> | getFuture()Returns the  Futureobject that was created whenstart()was called. | 
| protected int | getTaskCount()Returns the number of background tasks to be created for this
 initializer. | 
| protected abstract T | initialize()Performs the initialization. | 
| boolean | isStarted()Returns a flag whether this  BackgroundInitializerhas already
 been started. | 
| void | setExternalExecutor(ExecutorService externalExecutor)Sets an  ExecutorServiceto be used by this class. | 
| boolean | start()Starts the background initialization. | 
protected BackgroundInitializer()
BackgroundInitializer. No external
 ExecutorService is used.protected BackgroundInitializer(ExecutorService exec)
BackgroundInitializer and initializes
 it with the given ExecutorService. If the ExecutorService
 is not null, the background task for initializing this object will be
 scheduled at this service. Otherwise a new temporary ExecutorService is created.exec - an external ExecutorService to be used for task
 executionpublic final ExecutorService getExternalExecutor()
ExecutorService to be used by this class.ExecutorServicepublic boolean isStarted()
BackgroundInitializer has already
 been started.start() method has already been
 calledpublic final void setExternalExecutor(ExecutorService externalExecutor)
ExecutorService to be used by this class. The ExecutorService passed to this method is used for executing the
 background task. Thus it is possible to re-use an already existing
 ExecutorService or to use a specially configured one. If no
 ExecutorService is set, this instance creates a temporary one and
 destroys it after background initialization is complete. Note that this
 method must be called before start(); otherwise an exception is
 thrown.externalExecutor - the ExecutorService to be usedIllegalStateException - if this initializer has already been
 startedpublic boolean start()
initialize() method in a
 background task. A BackgroundInitializer can be started exactly
 once. The return value of this method determines whether the start was
 successful: only the first invocation of this method returns true,
 following invocations will return false.public T get() throws ConcurrentException
InterruptedException are wrapped in a
 ConcurrentException. Calling this method before start()
 was called causes an IllegalStateException exception to be
 thrown.get in interface ConcurrentInitializer<T>ConcurrentException - if a checked exception occurred during
 background processingIllegalStateException - if start() has not been calledpublic Future<T> getFuture()
Future object that was created when start()
 was called. Therefore this method can only be called after start().Future object wrapped by this initializerIllegalStateException - if start() has not been calledprotected final ExecutorService getActiveExecutor()
ExecutorService that is actually used for executing
 the background task. This method can be called after start()
 (before start() it returns null). If an external executor
 was set, this is also the active executor. Otherwise this method returns
 the temporary executor that was created by this object.ExecutorService for executing the background taskprotected int getTaskCount()
ExecutorService is created. This base implementation returns 1. Derived
 classes that do more complex background processing can override it. This
 method is called from a synchronized block by the start()
 method. Therefore overriding methods should be careful with obtaining
 other locks and return as fast as possible.protected abstract T initialize() throws Exception
BackgroundInitializer is started. It must be
 implemented by a concrete subclass. An implementation is free to perform
 arbitrary initialization. The object returned by this method can be
 queried using the get() method.Exception - if an error occursCopyright © 2001–2016 The Apache Software Foundation. All rights reserved.