Adjust checkstyle rules. Make checkstyle fail the build when violations are found. Correct all current checkstyle violations.

async-method-invocation/src/main/java/com/iluwatar/async/method/invocation/App.java

@@ -4,24 +4,23 @@ import java.util.concurrent.Callable;
 
 /**
  * This application demonstrates the async method invocation pattern. Key parts of the pattern are
- * <code>AsyncResult</code> which is an intermediate container for an asynchronously evaluated
- * value, <code>AsyncCallback</code> which can be provided to be executed on task completion and
- * <code>AsyncExecutor</code> that manages the execution of the async tasks.
+ * <code>AsyncResult</code> which is an intermediate container for an asynchronously evaluated value,
+ * <code>AsyncCallback</code> which can be provided to be executed on task completion and <code>AsyncExecutor</code>
+ * that manages the execution of the async tasks.
  * <p>
- * The main method shows example flow of async invocations. The main thread starts multiple tasks
- * with variable durations and then continues its own work. When the main thread has done it's job
- * it collects the results of the async tasks. Two of the tasks are handled with callbacks, meaning
- * the callbacks are executed immediately when the tasks complete.
+ * The main method shows example flow of async invocations. The main thread starts multiple tasks with variable
+ * durations and then continues its own work. When the main thread has done it's job it collects the results of the
+ * async tasks. Two of the tasks are handled with callbacks, meaning the callbacks are executed immediately when the
+ * tasks complete.
  * <p>
- * Noteworthy difference of thread usage between the async results and callbacks is that the async
- * results are collected in the main thread but the callbacks are executed within the worker
- * threads. This should be noted when working with thread pools.
+ * Noteworthy difference of thread usage between the async results and callbacks is that the async results are collected
+ * in the main thread but the callbacks are executed within the worker threads. This should be noted when working with
+ * thread pools.
  * <p>
- * Java provides its own implementations of async method invocation pattern. FutureTask,
- * CompletableFuture and ExecutorService are the real world implementations of this pattern. But due
- * to the nature of parallel programming, the implementations are not trivial. This example does not
- * take all possible scenarios into account but rather provides a simple version that helps to
- * understand the pattern.
+ * Java provides its own implementations of async method invocation pattern. FutureTask, CompletableFuture and
+ * ExecutorService are the real world implementations of this pattern. But due to the nature of parallel programming,
+ * the implementations are not trivial. This example does not take all possible scenarios into account but rather
+ * provides a simple version that helps to understand the pattern.
  *
  * @see AsyncResult
  * @see AsyncCallback
@@ -33,6 +32,9 @@ import java.util.concurrent.Callable;
  */
 public class App {
 
+  /**
+   * Program entry point
+   */
   public static void main(String[] args) throws Exception {
     // construct a new executor that will run async tasks
     AsyncExecutor executor = new ThreadAsyncExecutor();
@@ -41,10 +43,8 @@ public class App {
     AsyncResult<Integer> asyncResult1 = executor.startProcess(lazyval(10, 500));
     AsyncResult<String> asyncResult2 = executor.startProcess(lazyval("test", 300));
     AsyncResult<Long> asyncResult3 = executor.startProcess(lazyval(50L, 700));
-    AsyncResult<Integer> asyncResult4 =
-        executor.startProcess(lazyval(20, 400), callback("Callback result 4"));
-    AsyncResult<String> asyncResult5 =
-        executor.startProcess(lazyval("callback", 600), callback("Callback result 5"));
+    AsyncResult<Integer> asyncResult4 = executor.startProcess(lazyval(20, 400), callback("Callback result 4"));
+    AsyncResult<String> asyncResult5 = executor.startProcess(lazyval("callback", 600), callback("Callback result 5"));
 
     // emulate processing in the current thread while async tasks are running in their own threads
     Thread.sleep(350); // Oh boy I'm working hard here
@@ -66,8 +66,10 @@ public class App {
   /**
    * Creates a callable that lazily evaluates to given value with artificial delay.
    *
-   * @param value value to evaluate
-   * @param delayMillis artificial delay in milliseconds
+   * @param value
+   *          value to evaluate
+   * @param delayMillis
+   *          artificial delay in milliseconds
    * @return new callable for lazy evaluation
    */
   private static <T> Callable<T> lazyval(T value, long delayMillis) {
@@ -81,7 +83,8 @@ public class App {
   /**
    * Creates a simple callback that logs the complete status of the async result.
    *
-   * @param name callback name
+   * @param name
+   *          callback name
    * @return new async callback
    */
   private static <T> AsyncCallback<T> callback(String name) {

async-method-invocation/src/main/java/com/iluwatar/async/method/invocation/AsyncResult.java

@@ -5,8 +5,6 @@ import java.util.concurrent.ExecutionException;
 /**
  * 
  * AsyncResult interface
- *
- * @param <T>
  */
 public interface AsyncResult<T> {
 

async-method-invocation/src/main/java/com/iluwatar/async/method/invocation/ThreadAsyncExecutor.java

@@ -29,13 +29,12 @@ public class ThreadAsyncExecutor implements AsyncExecutor {
       } catch (Exception ex) {
         result.setException(ex);
       }
-    }, "executor-" + idx.incrementAndGet()).start();
+    } , "executor-" + idx.incrementAndGet()).start();
     return result;
   }
 
   @Override
-  public <T> T endProcess(AsyncResult<T> asyncResult) throws ExecutionException,
-      InterruptedException {
+  public <T> T endProcess(AsyncResult<T> asyncResult) throws ExecutionException, InterruptedException {
     if (asyncResult.isCompleted()) {
       return asyncResult.getValue();
     } else {
@@ -45,9 +44,8 @@ public class ThreadAsyncExecutor implements AsyncExecutor {
   }
 
   /**
-   * Simple implementation of async result that allows completing it successfully with a value or
-   * exceptionally with an exception. A really simplified version from its real life cousins
-   * FutureTask and CompletableFuture.
+   * Simple implementation of async result that allows completing it successfully with a value or exceptionally with an
+   * exception. A really simplified version from its real life cousins FutureTask and CompletableFuture.
    *
    * @see java.util.concurrent.FutureTask
    * @see java.util.concurrent.CompletableFuture
@@ -71,10 +69,11 @@ public class ThreadAsyncExecutor implements AsyncExecutor {
     }
 
     /**
-     * Sets the value from successful execution and executes callback if available. Notifies any
-     * thread waiting for completion.
+     * Sets the value from successful execution and executes callback if available. Notifies any thread waiting for
+     * completion.
      *
-     * @param value value of the evaluated task
+     * @param value
+     *          value of the evaluated task
      */
     void setValue(T value) {
       this.value = value;
@@ -86,10 +85,11 @@ public class ThreadAsyncExecutor implements AsyncExecutor {
     }
 
     /**
-     * Sets the exception from failed execution and executes callback if available. Notifies any
-     * thread waiting for completion.
+     * Sets the exception from failed execution and executes callback if available. Notifies any thread waiting for
+     * completion.
      *
-     * @param exception exception of the failed task
+     * @param exception
+     *          exception of the failed task
      */
     void setException(Exception exception) {
       this.exception = exception;