Javadoc

Author: garydgregory

src/main/java/org/apache/commons/lang3/concurrent/BackgroundInitializer.java

@@ -195,7 +195,7 @@ protected BackgroundInitializer() {
      * scheduled at this service. Otherwise a new temporary {@code
      * ExecutorService} is created.
      *
-     * @param exec an external {@link ExecutorService} to be used for task
+     * @param exec an external {@link ExecutorService} to be used for task.
      * execution
      */
     protected BackgroundInitializer(final ExecutorService exec) {
@@ -218,7 +218,7 @@ private BackgroundInitializer(final FailableSupplier<T, ConcurrentException> ini
      * Creates the {@link ExecutorService} to be used. This method is called if
      * no {@link ExecutorService} was provided at construction time.
      *
-     * @return the {@link ExecutorService} to be used
+     * @return the {@link ExecutorService} to be used.
      */
     private ExecutorService createExecutor() {
         return Executors.newFixedThreadPool(getTaskCount());
@@ -232,26 +232,26 @@ private ExecutorService createExecutor() {
      * at the end of the task.
      *
      * @param execDestroy the {@link ExecutorService} to be destroyed by the
-     * task
-     * @return a task for the background initialization
+     * task.
+     * @return a task for the background initialization.
      */
     private Callable<T> createTask(final ExecutorService execDestroy) {
         return new InitializationTask(execDestroy);
     }
 
     /**
-     * Returns the result of the background initialization. This method blocks
+     * Gets the result of the background initialization. This method blocks
      * until initialization is complete. If the background processing caused a
      * runtime exception, it is directly thrown by this method. Checked
      * exceptions, including {@link InterruptedException} are wrapped in a
      * {@link ConcurrentException}. Calling this method before {@link #start()}
      * was called causes an {@link IllegalStateException} exception to be
      * thrown.
      *
-     * @return the object produced by this initializer
+     * @return the object produced by this initializer.
      * @throws ConcurrentException if a checked exception occurred during
-     * background processing
-     * @throws IllegalStateException if {@link #start()} has not been called
+     * background processing.
+     * @throws IllegalStateException if {@link #start()} has not been called.
      */
     @Override
     public T get() throws ConcurrentException {
@@ -268,53 +268,52 @@ public T get() throws ConcurrentException {
     }
 
     /**
-     * Returns the {@link ExecutorService} that is actually used for executing
+     * Gets the {@link ExecutorService} that is actually used for executing
      * the background task. This method can be called after {@link #start()}
      * (before {@code start()} it returns <strong>null</strong>). 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.
      *
-     * @return the {@link ExecutorService} for executing the background task
+     * @return the {@link ExecutorService} for executing the background task.
      */
     protected final synchronized ExecutorService getActiveExecutor() {
         return executor;
     }
 
     /**
-     * Returns the external {@link ExecutorService} to be used by this class.
+     * Gets the external {@link ExecutorService} to be used by this class.
      *
-     * @return the {@link ExecutorService}
+     * @return the {@link ExecutorService}.
      */
     public final synchronized ExecutorService getExternalExecutor() {
         return externalExecutor;
     }
 
     /**
-     * Returns the {@link Future} object that was created when {@link #start()}
+     * Gets the {@link Future} object that was created when {@link #start()}
      * was called. Therefore this method can only be called after {@code
      * start()}.
      *
-     * @return the {@link Future} object wrapped by this initializer
-     * @throws IllegalStateException if {@link #start()} has not been called
+     * @return the {@link Future} object wrapped by this initializer.
+     * @throws IllegalStateException if {@link #start()} has not been called.
      */
     public synchronized Future<T> getFuture() {
         if (future == null) {
             throw new IllegalStateException("start() must be called first!");
         }
-
         return future;
     }
 
     /**
-     * Returns the number of background tasks to be created for this
+     * Gets the number of background tasks to be created for this
      * initializer. This information is evaluated when a temporary {@code
      * 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 {@link #start()}
      * method. Therefore overriding methods should be careful with obtaining
      * other locks and return as fast as possible.
      *
-     * @return the number of background tasks required by this initializer
+     * @return the number of background tasks required by this initializer.
      */
     protected int getTaskCount() {
         return 1;
@@ -334,15 +333,14 @@ protected Exception getTypedException(final Exception e) {
      * If initialization failed then the failure will be cached and this will never return
      * true.
      *
-     * @return true if initialization completed successfully, otherwise false
+     * @return true if initialization completed successfully, otherwise false.
      * @since 3.14.0
      */
     @Override
     public synchronized boolean isInitialized() {
-        if (future == null || ! future.isDone()) {
+        if (future == null || !future.isDone()) {
             return false;
         }
-
         try {
             future.get();
             return true;
@@ -356,7 +354,7 @@ public synchronized boolean isInitialized() {
      * been started.
      *
      * @return a flag whether the {@link #start()} method has already been
-     * called
+     * called.
      */
     public synchronized boolean isStarted() {
         return future != null;
@@ -372,17 +370,14 @@ public synchronized boolean isStarted() {
      * method must be called before {@link #start()}; otherwise an exception is
      * thrown.
      *
-     * @param externalExecutor the {@link ExecutorService} to be used
+     * @param externalExecutor the {@link ExecutorService} to be used.
      * @throws IllegalStateException if this initializer has already been
-     * started
+     * started.
      */
-    public final synchronized void setExternalExecutor(
-            final ExecutorService externalExecutor) {
+    public final synchronized void setExternalExecutor(final ExecutorService externalExecutor) {
         if (isStarted()) {
-            throw new IllegalStateException(
-                    "Cannot set ExecutorService after start()!");
+            throw new IllegalStateException("Cannot set ExecutorService after start()!");
         }
-
         this.externalExecutor = externalExecutor;
     }
 
@@ -394,27 +389,22 @@ public final synchronized void setExternalExecutor(
      * successful: only the first invocation of this method returns <strong>true</strong>,
      * following invocations will return <strong>false</strong>.
      *
-     * @return a flag whether the initializer could be started successfully
+     * @return a flag whether the initializer could be started successfully.
      */
     public synchronized boolean start() {
         // Not yet started?
         if (!isStarted()) {
-
-            // Determine the executor to use and whether a temporary one has to
-            // be created
+            // Determine the executor to use and whether a temporary one has to be created.
             final ExecutorService tempExec;
             executor = getExternalExecutor();
             if (executor == null) {
                 executor = tempExec = createExecutor();
             } else {
                 tempExec = null;
             }
-
             future = executor.submit(createTask(tempExec));
-
             return true;
         }
-
         return false;
     }
 }