diff --git a/JavaMultiThreadingCodes/src/CallableAndFuture_13/CallableTester.java b/JavaMultiThreadingCodes/src/CallableAndFuture_13/CallableTester.java
index 29c75aa..8fd3511 100644
--- a/JavaMultiThreadingCodes/src/CallableAndFuture_13/CallableTester.java
+++ b/JavaMultiThreadingCodes/src/CallableAndFuture_13/CallableTester.java
@@ -18,7 +18,7 @@
  * Runnable Introduced in Java 1.0 Callable<T> Introduced in Java 1.5 as part of
  * java.util.concurrent library
  *
- * Runnable cannot be parameterized Callable is a parameterized type whose type
+ * Runnable cannot be parametrized Callable is a parametrized type whose type
  * parameter indicates the return type of its run method Classes implementing
  *
  * Runnable needs to implement run() method, classes implementing Callable needs
diff --git a/JavaMultiThreadingCodes/src/CountDownLatch_6/App.java b/JavaMultiThreadingCodes/src/CountDownLatch_6/App.java
index 646efe7..20164d7 100644
--- a/JavaMultiThreadingCodes/src/CountDownLatch_6/App.java
+++ b/JavaMultiThreadingCodes/src/CountDownLatch_6/App.java
@@ -5,30 +5,34 @@
 import java.util.concurrent.Executors;
 
 /**
- * CountDownLatch Java class to synchronize your threads’ activities.
- *
+ * {@link java.util.concurrent.CountDownLatch} Java class to synchronize your threads’ activities.
+ * <br><br>
  * Source:
- * (http://stackoverflow.com/questions/17827022/what-is-countdown-latch-in-java-multithreading)
+ * <em>http://stackoverflow.com/questions/17827022/what-is-countdown-latch-in-java-multithreading</em><br>
+ *
  * Any thread, usually main thread of application, which calls
- * CountDownLatch.await() will wait until count reaches zero or its interrupted
+ * {@link java.util.concurrent.CountDownLatch#await()} will wait until count reaches zero or its interrupted
  * by another thread. All other thread are required to do count down by calling
- * CountDownLatch.countDown() once they are completed or ready.
- *
+ * {@link java.util.concurrent.CountDownLatch#countDown()} once they are completed or ready.
+ * <br>
  * As soon as count reaches zero, Thread awaiting starts running. One of the
- * disadvantage of CountDownLatch is that its not reusable once count reaches to
- * zero you can not use CountDownLatch any more.
- *
- * Use CountDownLatch when one thread like main thread, require to wait for one
- * or more thread to complete, before it can start processing.
- *
- * Classical example of using CountDownLatch in Java is any server side core
- * Java application which uses services architecture, where multiple services
+ * disadvantage of {@link java.util.concurrent.CountDownLatch} is that it's
+ * not reusable once the count reaches to
+ * zero you can not use {@link java.util.concurrent.CountDownLatch} any more.
+ * <br><br>
+ * Use {@link java.util.concurrent.CountDownLatch} when one thread, like main
+ * thread, require to wait for one or more threads to complete, before it can
+ * start processing.
+ * <br><br>
+ * Classical example of using {@link java.util.concurrent.CountDownLatch} in
+ * Java is any server side core  Java application which uses services
+ * architecture, where multiple services
  * are provided by multiple threads and application can not start processing
  * until all services have started successfully.
- *
- * Codes with minor comments are from http://www.caveofprogramming.com/youtube/
+ * <br><br>
+ * Codes with minor comments are from <em>http://www.caveofprogramming.com/youtube/</em><br>
  * also freely available at
- * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ * <em>https://www.udemy.com/java-multithreading/?couponCode=FREE</em>
  *
  * @author Z.B. Celik <celik.berkay@gmail.com>
  */
@@ -45,10 +49,7 @@ public void run() {
 
         try {
             Thread.sleep(3000);
-        } catch (InterruptedException e) {
-            // TODO Auto-generated catch block
-            e.printStackTrace();
-        }
+        } catch (InterruptedException ignored) {}
         latch.countDown();
     }
 }
@@ -61,8 +62,10 @@ public static void main(String[] args) {
         for (int i = 0; i < 3; i++) {
             executor.submit(new Processor(latch));
         }
+        executor.shutdown();
+
         try {
-            // Application’s main thread waits, till other service threads which are 
+            // Application’s main thread waits, till other service threads which are
             // as an example responsible for starting framework services have completed started all services.
             latch.await();
         } catch (InterruptedException e) {
diff --git a/JavaMultiThreadingCodes/src/Deadlock_11/Runner.java b/JavaMultiThreadingCodes/src/Deadlock_11/Runner.java
index f293f41..970d502 100644
--- a/JavaMultiThreadingCodes/src/Deadlock_11/Runner.java
+++ b/JavaMultiThreadingCodes/src/Deadlock_11/Runner.java
@@ -53,7 +53,7 @@ private void acquireLocks(Lock firstLock, Lock secondLock) throws InterruptedExc
         }
     }
 
-    //firstThreaad runs
+    //firstThread runs
     public void firstThread() throws InterruptedException {
         Random random = new Random();
         for (int i = 0; i < 10000; i++) {
diff --git a/JavaMultiThreadingCodes/src/Deadlock_11/SimpleDeadLock.java b/JavaMultiThreadingCodes/src/Deadlock_11/SimpleDeadLock.java
index 47f769a..10a9594 100644
--- a/JavaMultiThreadingCodes/src/Deadlock_11/SimpleDeadLock.java
+++ b/JavaMultiThreadingCodes/src/Deadlock_11/SimpleDeadLock.java
@@ -10,8 +10,8 @@
  */
 public class SimpleDeadLock {
 
-    public static Object lock1 = new Object();
-    public static Object lock2 = new Object();
+    public static final Object lock1 = new Object();
+    public static final Object lock2 = new Object();
     private int index;
 
     public static void main(String[] a) {
@@ -28,7 +28,7 @@ public void run() {
                 System.out.println("Thread 1: Holding lock 1...");
                 try {
                     Thread.sleep(10);
-                } catch (InterruptedException e) {
+                } catch (InterruptedException ignored) {
                 }
                 System.out.println("Thread 1: Waiting for lock 2...");
                 synchronized (lock2) {
@@ -45,7 +45,7 @@ public void run() {
                 System.out.println("Thread 2: Holding lock 2...");
                 try {
                     Thread.sleep(10);
-                } catch (InterruptedException e) {
+                } catch (InterruptedException ignored) {
                 }
                 System.out.println("Thread 2: Waiting for lock 1...");
                 synchronized (lock1) {
diff --git a/JavaMultiThreadingCodes/src/InterruptingThreads14/App.java b/JavaMultiThreadingCodes/src/InterruptingThreads14/App.java
index f36769c..165a460 100644
--- a/JavaMultiThreadingCodes/src/InterruptingThreads14/App.java
+++ b/JavaMultiThreadingCodes/src/InterruptingThreads14/App.java
@@ -31,9 +31,9 @@ public static void main(String[] args) throws InterruptedException {
 
         System.out.println("Starting.");
 
-        ExecutorService executer = Executors.newCachedThreadPool();
+        ExecutorService executor = Executors.newCachedThreadPool();
 
-        Future<?> fu = executer.submit(new Callable<Void>() {
+        Future<?> fu = executor.submit(new Callable<Void>() {
 
             @Override
             public Void call() throws Exception {
@@ -49,11 +49,11 @@ public Void call() throws Exception {
             }
         });
 
-        executer.shutdown();
+        executor.shutdown();
         Thread.sleep(500);
-        executer.shutdownNow();
+        executor.shutdownNow();
 
-        executer.awaitTermination(1, TimeUnit.DAYS);
+        executor.awaitTermination(1, TimeUnit.DAYS);
         System.out.println("Finished.");
     }
 
diff --git a/JavaMultiThreadingCodes/src/JoiningAndSynchronizeThreads_3/Worker.java b/JavaMultiThreadingCodes/src/JoiningAndSynchronizeThreads_3/Worker.java
index d2bb0c3..a419f3c 100644
--- a/JavaMultiThreadingCodes/src/JoiningAndSynchronizeThreads_3/Worker.java
+++ b/JavaMultiThreadingCodes/src/JoiningAndSynchronizeThreads_3/Worker.java
@@ -4,12 +4,12 @@
 import java.util.logging.Logger;
 
 /**
- * synchronized ("only let one thread in here at a time".) and join ("wait until
+ * {@code synchronized} ("only let one thread in here at a time".) and {@code join} ("wait until
  * thread on which join has called finished") keyword.
- *
- * Codes with minor comments are from http://www.caveofprogramming.com/youtube/
+ * <br><br>
+ * Codes with minor comments are from <em>http://www.caveofprogramming.com/youtube/</em><br>
  * also freely available at
- * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ * <em>https://www.udemy.com/java-multithreading/?couponCode=FREE</em>
  *
  * @author Z.B. Celik <celik.berkay@gmail.com>
  */
@@ -70,10 +70,7 @@ public void run() {
         try {
             thread1.join();
             thread2.join();
-        } catch (InterruptedException e) {
-            // TODO Auto-generated catch block
-            e.printStackTrace();
-        }
+        } catch (InterruptedException ignored) {}
         System.out.println("Count is: " + count);
     }
 }
diff --git a/JavaMultiThreadingCodes/src/LockObjects_4/App.java b/JavaMultiThreadingCodes/src/LockObjects_4/App.java
index 96b6a13..e98d96f 100644
--- a/JavaMultiThreadingCodes/src/LockObjects_4/App.java
+++ b/JavaMultiThreadingCodes/src/LockObjects_4/App.java
@@ -1,9 +1,9 @@
 package LockObjects_4;
 
 /**
- * Codes with minor comments are from http://www.caveofprogramming.com/youtube/
+ * Codes with minor comments are from <em>http://www.caveofprogramming.com/youtube/</em><br>
  * also freely available at
- * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ * <em>https://www.udemy.com/java-multithreading/?couponCode=FREE</em>
  *
  * @author Z.B. Celik <celik.berkay@gmail.com>
  */
diff --git a/JavaMultiThreadingCodes/src/LockObjects_4/Worker.java b/JavaMultiThreadingCodes/src/LockObjects_4/Worker.java
index ae381bb..fd5d7a7 100644
--- a/JavaMultiThreadingCodes/src/LockObjects_4/Worker.java
+++ b/JavaMultiThreadingCodes/src/LockObjects_4/Worker.java
@@ -21,11 +21,11 @@ public class Worker {
 
     private Random random = new Random();
 
-    private Object lock1 = new Object();
-    private Object lock2 = new Object();
+    private final Object lock1 = new Object();
+    private final Object lock2 = new Object();
 
-    private List<Integer> list1 = new ArrayList<Integer>();
-    private List<Integer> list2 = new ArrayList<Integer>();
+    private List<Integer> list1 = new ArrayList<>();
+    private List<Integer> list2 = new ArrayList<>();
 
     public void stageOne() {
 
diff --git a/JavaMultiThreadingCodes/src/LockObjects_4/WorkerMethodsSynchronized.java b/JavaMultiThreadingCodes/src/LockObjects_4/WorkerMethodsSynchronized.java
index 5b7ac30..d122f57 100644
--- a/JavaMultiThreadingCodes/src/LockObjects_4/WorkerMethodsSynchronized.java
+++ b/JavaMultiThreadingCodes/src/LockObjects_4/WorkerMethodsSynchronized.java
@@ -21,8 +21,8 @@ public class WorkerMethodsSynchronized {
 
     private Random random = new Random();
 
-    private List<Integer> list1 = new ArrayList<Integer>();
-    private List<Integer> list2 = new ArrayList<Integer>();
+    private List<Integer> list1 = new ArrayList<>();
+    private List<Integer> list2 = new ArrayList<>();
 
     /**
      * synchronized, methods use different data (list1 list2) so by synchronized
@@ -78,10 +78,7 @@ public void run() {
         try {
             t1.join();
             t2.join();
-        } catch (InterruptedException e) {
-            // TODO Auto-generated catch block
-            e.printStackTrace();
-        }
+        } catch (InterruptedException ignored) {}
 
         long end = System.currentTimeMillis();
 
diff --git a/JavaMultiThreadingCodes/src/LowLevelProducerConsumer_9/App.java b/JavaMultiThreadingCodes/src/LowLevelProducerConsumer_9/App.java
index 99eb416..3e62cf3 100644
--- a/JavaMultiThreadingCodes/src/LowLevelProducerConsumer_9/App.java
+++ b/JavaMultiThreadingCodes/src/LowLevelProducerConsumer_9/App.java
@@ -1,15 +1,16 @@
 package LowLevelProducerConsumer_9;
 
 /**
- * How to implement the producer-consumer pattern using "low level" techniques;
+ * How to implement the Producer-Consumer pattern using "low level" techniques;
  * namely, wait, notify and synchronized. This isn't the best way to implement a
- * producer-consumer pattern in Java (see tutorial 7 use of BlockingQueue for
+ * Producer-Consumer pattern in Java
+ * (see tutorial 7 use of {@link java.util.concurrent.BlockingQueue} for
  * the best way); but this tutorial will help you to understand how to use wait
  * and notify.
- *
- * Codes with minor comments are from http://www.caveofprogramming.com/youtube/
+ * <br><br>
+ * Codes with minor comments are from <em>http://www.caveofprogramming.com/youtube/</em><br>
  * also freely available at
- * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ * <em>https://www.udemy.com/java-multithreading/?couponCode=FREE</em>
  *
  * @author Z.B. Celik <celik.berkay@gmail.com>
  */
@@ -22,9 +23,7 @@ public static void main(String[] args) throws InterruptedException {
             public void run() {
                 try {
                     processor.produce();
-                } catch (InterruptedException e) {
-                    e.printStackTrace();
-                }
+                } catch (InterruptedException ignored) {}
             }
         });
 
@@ -33,14 +32,18 @@ public void run() {
             public void run() {
                 try {
                     processor.consume();
-                } catch (InterruptedException e) {
-                    e.printStackTrace();
-                }
+                } catch (InterruptedException ignored) {}
             }
         });
+
         t1.start();
         t2.start();
-        t1.join();
-        t2.join();
+//        t1.join();
+//        t2.join();
+
+        // Pause for 30 seconds and force quitting the app (because we're
+        // looping infinitely)
+        Thread.sleep(30000);
+        System.exit(0);
     }
 }
diff --git a/JavaMultiThreadingCodes/src/LowLevelProducerConsumer_9/Processor.java b/JavaMultiThreadingCodes/src/LowLevelProducerConsumer_9/Processor.java
index a93ba04..e9f5a1d 100644
--- a/JavaMultiThreadingCodes/src/LowLevelProducerConsumer_9/Processor.java
+++ b/JavaMultiThreadingCodes/src/LowLevelProducerConsumer_9/Processor.java
@@ -1,26 +1,27 @@
 package LowLevelProducerConsumer_9;
 
 /**
- * Codes with minor comments are from http://www.caveofprogramming.com/youtube/
+ * Codes with minor comments are from <em>http://www.caveofprogramming.com/youtube/</em><br>
  * also freely available at
- * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ * <em>https://www.udemy.com/java-multithreading/?couponCode=FREE</em>
  *
  * @author Z.B. Celik <celik.berkay@gmail.com>
  */
 import java.util.LinkedList;
 import java.util.Random;
 
+@SuppressWarnings("InfiniteLoopStatement")
 public class Processor {
 
     private LinkedList<Integer> list = new LinkedList<>();
     private final int LIMIT = 10;
-    private Object lock = new Object();
+    private final Object lock = new Object();
 
     public void produce() throws InterruptedException {
         int value = 0;
         while (true) {
             synchronized (lock) {
-                //whenever the threade is notofied starts again from the loop
+                //whenever the thread is notified starts again from the loop
                 while (list.size() == LIMIT) {
                     lock.wait();// wait() is also true
                 }
diff --git a/JavaMultiThreadingCodes/src/ProducerConsumer_7/App.java b/JavaMultiThreadingCodes/src/ProducerConsumer_7/App.java
index 7440082..1f62f46 100644
--- a/JavaMultiThreadingCodes/src/ProducerConsumer_7/App.java
+++ b/JavaMultiThreadingCodes/src/ProducerConsumer_7/App.java
@@ -1,14 +1,16 @@
 package ProducerConsumer_7;
 
 /**
- * producer-consumer pattern in Java using the ArrayBlockingQueue Java class.
+ * Producer-Consumer pattern in Java using the {@link java.util.concurrent
+ * .ArrayBlockingQueue} Java class.
+ * <br><br>
  * Producer-Consumer is the situation where one or more threads are producing
  * data items and adding them to a shared data store of some kind while one or
  * more other threads process those items, removing them from the data store.
- *
- * Codes with minor comments are from http://www.caveofprogramming.com/youtube/
+ * <br><br>
+ * Codes with minor comments are from <em>http://www.caveofprogramming.com/youtube/</em><br>
  * also freely available at
- * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ * <em>https://www.udemy.com/java-multithreading/?couponCode=FREE</em>
  *
  * @author Z.B. Celik <celik.berkay@gmail.com>
  */
@@ -16,32 +18,31 @@
 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.BlockingQueue;
 
+@SuppressWarnings("InfiniteLoopStatement")
 public class App {
 
     /**
-     * Thread safe implementation of Queue data structure so you do not need to
-     * worry about synchronization. More specifically BlockingQueue
+     * Thread safe implementation of {@link java.util.Queue} data structure so
+     * you do not need to worry about synchronization.
+     * More specifically {@link java.util.concurrent.BlockingQueue}
      * implementations are thread-safe. All queuing methods are atomic in nature
      * and use internal locks or other forms of concurrency control. If
      * BlockingQueue is not used queue is shared data structure either
-     * sychronized or wait() notify() (see Course 8) should be used. Java 1.5
-     * introduced a new concurrency library (in the java.util.concurrent
-     * package) which was designed to provide a higher level abstraction over
+     * {@code synchronized} or {@code wait() notify()} (see Course 8) should be
+     * used.
+     * Java 1.5 introduced a new concurrency library {@link java.util.concurrent}
+     * which was designed to provide a higher level abstraction over
      * the wait/notify mechanism.
      */
     private static BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);
 
     public static void main(String[] args) throws InterruptedException {
-        /**
-         *
-         */
+
         Thread t1 = new Thread(new Runnable() {
             public void run() {
                 try {
                     producer();
-                } catch (InterruptedException e) {
-                    e.printStackTrace();
-                }
+                } catch (InterruptedException ignored) {}
             }
         });
 
@@ -49,16 +50,18 @@ public void run() {
             public void run() {
                 try {
                     consumer();
-                } catch (InterruptedException e) {
-                    // TODO Auto-generated catch block
-                    e.printStackTrace();
-                }
+                } catch (InterruptedException ignored) {}
             }
         });
         t1.start();
         t2.start();
-        t1.join();
-        t2.join();
+//        t1.join();
+//        t2.join();
+
+        // Pause for 30 seconds and force quitting the app (because we're
+        // looping infinitely)
+        Thread.sleep(30000);
+        System.exit(0);
     }
 
     private static void producer() throws InterruptedException {
@@ -71,7 +74,7 @@ private static void producer() throws InterruptedException {
     private static void consumer() throws InterruptedException {
         Random random = new Random();
         while (true) {
-            //Thread.sleep(100);
+            Thread.sleep(100);
             if (random.nextInt(10) == 0) {
                 Integer value = queue.take();//if queue is empty waits
                 System.out.println("Taken value: " + value + "; Queue size is: " + queue.size());
diff --git a/JavaMultiThreadingCodes/src/ReentrantLocks_10/App.java b/JavaMultiThreadingCodes/src/ReentrantLocks_10/App.java
index 96a43b8..3e17bff 100644
--- a/JavaMultiThreadingCodes/src/ReentrantLocks_10/App.java
+++ b/JavaMultiThreadingCodes/src/ReentrantLocks_10/App.java
@@ -1,36 +1,62 @@
 package ReentrantLocks_10;
 
 /**
- * the ReentrantLock class in Java as an alternative to synchronized code
- * blocks. ReentrantLocks let you do all the stuff that you can do with
- * synchronized, wait and notify, plus some more stuff besides that may come in
+ * the {@link java.util.concurrent.locks.ReentrantLock} class in Java as an
+ * alternative to synchronized code blocks.
+ * <br>
+ * {@link java.util.concurrent.locks.ReentrantLock}s let you do all the
+ * stuff that you can do with {@code synchronized}, {@link Object#wait()} and
+ * {@link Object#notify()}, plus some more stuff. Besides that may come in
  * handy from time to time.
- *
- * Source:
+ * <br><br>
+ * Source:<em>
  * http://docs.oracle.com/javase/1.5.0/docs/api/java/util/concurrent/locks/ReentrantLock.html
- *
- * ReentrantLock Extended capabilities include:
- *
- * The ability to have more than one condition variable per monitor. Monitors
- * that use the synchronized keyword can only have one. This means reentrant
- * locks support more than one wait()/notify() queue. The ability to make the
- * lock "fair". "[fair] locks favor granting access to the longest-waiting
+ * </em>
+ * <br><br>
+ * {@link java.util.concurrent.locks.ReentrantLock} Extended capabilities
+ * include:
+ * <br>
+ * <ul>
+ * <li>
+ * The ability to have more than one {@link java.util.concurrent.locks.Condition}
+ * variable per monitor.
+ * </li>
+ * <li>Monitors that use the synchronized keyword can only have one. This means
+ * {@link java.util.concurrent.locks.ReentrantLock}s support more than one
+ * {@link Object#wait()}/{@link Object#notify()} queue.
+ * </li>
+ * <li>
+ * The ability to make the lock "fair".
+ * <em>
+ * "[fair] locks favor granting access to the longest-waiting
  * thread. Otherwise this lock does not guarantee any particular access order."
- * Synchronized blocks are unfair. The ability to check if the lock is being
- * held. The ability to get the list of threads waiting on the lock.
- *
- * The disadvantages of reentrant locks are:
- *
- * Need to add import statement. Need to wrap lock acquisitions in a try/finally
- * block. This makes it more ugly than the synchronized keyword. The
- * synchronized keyword can be put in method definitions which avoids the need
- * for a block which reduces nesting. For more complete comparison of
- * reentrantLocks and synchronized see
+ * </em>
+ * </li>
+ * <li>Synchronized blocks are unfair.</li>
+ * <li>The ability to check if the lock is being
+ * held.</li>
+ * <li>The ability to get the list of threads waiting on the lock.</li>
+ * </ul>
+ * <br><br>
+ * The disadvantages of {@link java.util.concurrent.locks.ReentrantLock}s are:
+ * <br>
+ * <ul>
+ * <li>Need to add import statement.</li>
+ * <li>Need to wrap lock acquisitions in a try/finally block. This makes it more
+ * ugly than the synchronized keyword.</li>
+ * <li>The synchronized keyword can be put in method definitions which avoids
+ * the need for a block which reduces nesting.</li>
+ * </ul>
+ * <br><br>
+ * For more complete comparison of
+ * {@link java.util.concurrent.locks.ReentrantLock}s and {@code synchronized}
+ * see:<em>
  * http://guruzon.com/1/concurrency/explicit-lock-locking/difference-between-synchronized-and-reentrantlock-in-java
- *
- * Codes with minor comments are from http://www.caveofprogramming.com/youtube/
+ * </em>
+ * <br><br>
+ * Codes with minor comments are from <em>http://www.caveofprogramming.com/youtube/</em><br>
  * also freely available at
- * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ * <em>https://www.udemy.com/java-multithreading/?couponCode=FREE</em>
  *
  * @author Z.B. Celik <celik.berkay@gmail.com>
  */
@@ -42,8 +68,7 @@ public static void main(String[] args) throws Exception {
             public void run() {
                 try {
                     runner.firstThread();
-                } catch (InterruptedException e) {
-                    e.printStackTrace();
+                } catch (InterruptedException ignored) {
                 }
             }
         });
@@ -52,8 +77,7 @@ public void run() {
             public void run() {
                 try {
                     runner.secondThread();
-                } catch (InterruptedException e) {
-                    e.printStackTrace();
+                } catch (InterruptedException ignored) {
                 }
             }
         });
diff --git a/JavaMultiThreadingCodes/src/ReentrantLocks_10/Runner.java b/JavaMultiThreadingCodes/src/ReentrantLocks_10/Runner.java
index 018f5d6..4159ea3 100644
--- a/JavaMultiThreadingCodes/src/ReentrantLocks_10/Runner.java
+++ b/JavaMultiThreadingCodes/src/ReentrantLocks_10/Runner.java
@@ -1,36 +1,46 @@
 package ReentrantLocks_10;
 
+import java.util.Scanner;
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
 /**
- * Source:http://www.journaldev.com/2377/java-lock-example-and-concurrency-lock-vs-synchronized
- *
- * Lock: This is the base interface for Lock API. It provides all the features
+ * Source:<em>
+ * http://www.journaldev.com/2377/java-lock-example-and-concurrency-lock-vs-synchronized</em>
+ * <p>
+ * {@link java.util.concurrent.locks.Lock}:
+ * This is the base interface for Lock API. It provides all the features
  * of synchronized keyword with additional ways to create different Conditions
  * for locking, providing timeout for thread to wait for lock. Some of the
- * important methods are lock() to acquire the lock, unlock() to release the
- * lock, tryLock() to wait for lock for a certain period of time, newCondition()
+ * important methods are {@link java.util.concurrent.locks.Lock#lock()} to
+ * acquire the lock, {@link java.util.concurrent.locks.Lock#unlock()} to release
+ * the lock, {@link java.util.concurrent.locks.Lock#tryLock()} to wait for lock
+ * for a certain period of time,
+ * {@link java.util.concurrent.locks.Lock#newCondition()}
  * to create the Condition etc.
- *
- * ReentrantLock: This is the most widely used implementation class of Lock
+ * <p>
+ * {@link java.util.concurrent.locks.ReentrantLock}:
+ * This is the most widely used implementation class of Lock
  * interface. This class implements the Lock interface in similar way as
  * synchronized keyword. (see App.java for more)
- *
- * Condition: Condition objects are similar to Object wait-notify model with
+ * <p>
+ * {@link java.util.concurrent.locks.Condition}:
+ * Condition objects are similar to Object wait-notify model with
  * additional feature to create different sets of wait. A Condition object is
- * always created by Lock object. Some of the important methods are await() that
- * is similar to wait() and signal(), signalAll() that is similar to notify()
- * and notifyAll() methods.
- *
- * Codes with minor comments are from http://www.caveofprogramming.com/youtube/
+ * always created by Lock object. Some of the important methods are
+ * {@link java.util.concurrent.locks.Condition#await()}
+ * that is similar to {@link Object#wait()}.
+ * {@link java.util.concurrent.locks.Condition#signal()} and
+ * {@link java.util.concurrent.locks.Condition#signalAll()}
+ * that are similar to
+ * {@link Object#notify()} and {@link Object#notifyAll()} methods.
+ * <br><br>
+ * Codes with minor comments are from <em>http://www.caveofprogramming.com/youtube/</em><br>
  * also freely available at
- * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ * <em>https://www.udemy.com/java-multithreading/?couponCode=FREE</em>
  *
  * @author Z.B. Celik <celik.berkay@gmail.com>
  */
-import java.util.Scanner;
-import java.util.concurrent.locks.Condition;
-import java.util.concurrent.locks.Lock;
-import java.util.concurrent.locks.ReentrantLock;
-
 public class Runner {
 
     private int count = 0;
@@ -65,7 +75,8 @@ public void secondThread() throws InterruptedException {
         try {
             increment();
         } finally {
-            lock.unlock();//should be written to unlock Thread whenever signal() is called
+            //should be written to unlock Thread whenever signal() is called
+            lock.unlock();
         }
     }
 
diff --git a/JavaMultiThreadingCodes/src/Semaphores_12/App.java b/JavaMultiThreadingCodes/src/Semaphores_12/App.java
index dcccb55..6c1790b 100644
--- a/JavaMultiThreadingCodes/src/Semaphores_12/App.java
+++ b/JavaMultiThreadingCodes/src/Semaphores_12/App.java
@@ -40,7 +40,7 @@ public class App {
 
     public static void main(String[] args) throws Exception {
         ExecutorService executor = Executors.newCachedThreadPool();
-        for (int i = 0; i < 13; i++) { //200 hundred times will be calleds
+        for (int i = 0; i < 13; i++) { //200 hundred times will be called
             executor.submit(new Runnable() {
                 public void run() {
                     Connection.getInstance().connect();
diff --git a/JavaMultiThreadingCodes/src/Semaphores_12/Connection.java b/JavaMultiThreadingCodes/src/Semaphores_12/Connection.java
index f8f22c8..b4c77d7 100644
--- a/JavaMultiThreadingCodes/src/Semaphores_12/Connection.java
+++ b/JavaMultiThreadingCodes/src/Semaphores_12/Connection.java
@@ -15,8 +15,8 @@ public class Connection {
 
     private static Connection instance = new Connection();
     //limit connections to 10
-    //true means whichever the thread call the acquire first gets it first, 
-    //in queue placed firts to obtain the permit.
+    //true means whichever the thread call the acquire first gets it first,
+    //in queue placed first to obtain the permit.
     private Semaphore sem = new Semaphore(10, true);
     private int connections = 0;
 
@@ -34,7 +34,7 @@ public void connect() {
             e1.printStackTrace();
         }
         try {
-            //if doConnect throws and exception is still releases the permit 
+            //if doConnect throws and exception is still releases the permit
             //so we use a separate method here to increase the connections count.
             doConnect();
         } finally {
@@ -55,7 +55,7 @@ public void doConnect() {
             e.printStackTrace();
         }
         //when exit doConnect method decrement number of connections
-        synchronized (this) {//atamoic
+        synchronized (this) {//atomic
             connections--;
             System.out.println("I'm done " + Thread.currentThread().getName() + " Connection is released , connection count: " + connections);
         }
diff --git a/JavaMultiThreadingCodes/src/StartingThreads_1/ApplicationAnonymous.java b/JavaMultiThreadingCodes/src/StartingThreads_1/ApplicationAnonymous.java
index cd99566..fd61eb2 100644
--- a/JavaMultiThreadingCodes/src/StartingThreads_1/ApplicationAnonymous.java
+++ b/JavaMultiThreadingCodes/src/StartingThreads_1/ApplicationAnonymous.java
@@ -2,10 +2,10 @@
 
 /**
  * Starting threads using the Thread constructor with anonymous classes
- *
- * Codes with minor comments are from http://www.caveofprogramming.com/youtube/
+ * <br><br>
+ * Codes with minor comments are from <em>http://www.caveofprogramming.com/youtube/</em><br>
  * also freely available at
- * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ * <em>https://www.udemy.com/java-multithreading/?couponCode=FREE</em>
  *
  * @author Z.B. Celik <celik.berkay@gmail.com>
  */
@@ -20,10 +20,7 @@ public void run() {
 
                     try {
                         Thread.sleep(100);
-                    } catch (InterruptedException e) {
-                        // TODO Auto-generated catch block
-                        e.printStackTrace();
-                    }
+                    } catch (InterruptedException ignored) {}
                 }
             }
         });
diff --git a/JavaMultiThreadingCodes/src/StartingThreads_1/ApplicationExtends.java b/JavaMultiThreadingCodes/src/StartingThreads_1/ApplicationExtends.java
index fbbac2e..e966135 100644
--- a/JavaMultiThreadingCodes/src/StartingThreads_1/ApplicationExtends.java
+++ b/JavaMultiThreadingCodes/src/StartingThreads_1/ApplicationExtends.java
@@ -2,10 +2,9 @@
 
 /**
  * Starting Threads with extends
- * 
- * Codes with minor comments are from
- * http://www.caveofprogramming.com/youtube/ also freely available at
- * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ * <br><br>
+ * Codes with minor comments are from <em>http://www.caveofprogramming.com/youtube/</em><br>
+ * also freely available at <em>https://www.udemy.com/java-multithreading/?couponCode=FREE</em>
  *
  * @author Z.B. Celik <celik.berkay@gmail.com>
  */
diff --git a/JavaMultiThreadingCodes/src/StartingThreads_1/ApplicationRunnable.java b/JavaMultiThreadingCodes/src/StartingThreads_1/ApplicationRunnable.java
index 5d5237a..768cfc3 100644
--- a/JavaMultiThreadingCodes/src/StartingThreads_1/ApplicationRunnable.java
+++ b/JavaMultiThreadingCodes/src/StartingThreads_1/ApplicationRunnable.java
@@ -2,10 +2,9 @@
 
 /**
  * Starting Threads using Runnable Interface
- *
- * Codes with minor comments are from http://www.caveofprogramming.com/youtube/
- * also freely available at
- * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ * <br><br>
+ * Codes with minor comments are from <em>http://www.caveofprogramming.com/youtube/</em><br>
+ * also freely available at: <em>https://www.udemy.com/java-multithreading/?couponCode=FREE</em>
  *
  * @author Z.B. Celik <celik.berkay@gmail.com>
  */
diff --git a/JavaMultiThreadingCodes/src/ThreadPools_5/App.java b/JavaMultiThreadingCodes/src/ThreadPools_5/App.java
index c94b1c6..649ea6c 100644
--- a/JavaMultiThreadingCodes/src/ThreadPools_5/App.java
+++ b/JavaMultiThreadingCodes/src/ThreadPools_5/App.java
@@ -2,10 +2,10 @@
 
 /**
  * ThreadPool ("number of workers in a factory")
- *
- * Codes with minor comments are from http://www.caveofprogramming.com/youtube/
+ * <br><br>
+ * Codes with minor comments are from <em>http://www.caveofprogramming.com/youtube/</em><br>
  * also freely available at
- * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ * <em>https://www.udemy.com/java-multithreading/?couponCode=FREE</em>
  *
  * @author Z.B. Celik <celik.berkay@gmail.com>
  */
@@ -25,7 +25,7 @@ public void run() {
         System.out.println("Starting: " + id);
         try {
             Thread.sleep(5000);
-        } catch (InterruptedException e) {
+        } catch (InterruptedException ignored) {
         }
         System.out.println("Completed: " + id);
     }
@@ -45,7 +45,7 @@ public static void main(String[] args) {
         System.out.println("All tasks submitted.");
         try {
             executor.awaitTermination(1, TimeUnit.DAYS);
-        } catch (InterruptedException e) {
+        } catch (InterruptedException ignored) {
         }
         System.out.println("All tasks completed.");
     }
diff --git a/JavaMultiThreadingCodes/src/ThreadPools_5/WorkerThreadPool.java b/JavaMultiThreadingCodes/src/ThreadPools_5/WorkerThreadPool.java
index 1535f50..5da9ee5 100644
--- a/JavaMultiThreadingCodes/src/ThreadPools_5/WorkerThreadPool.java
+++ b/JavaMultiThreadingCodes/src/ThreadPools_5/WorkerThreadPool.java
@@ -8,19 +8,19 @@
 import java.util.concurrent.TimeUnit;
 
 /**
- * This is the implementation of LockObjects_4.Worker with threadPool
- *
- * Codes with minor comments are from http://www.caveofprogramming.com/youtube/
+ * This is the implementation of {@link LockObjects_4.Worker} with threadPool
+ * <br><br>
+ * Codes with minor comments are from <em>http://www.caveofprogramming.com/youtube/</em><br>
  * also freely available at
- * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ * <em>https://www.udemy.com/java-multithreading/?couponCode=FREE</em>
  *
  * @author Z.B. Celik <celik.berkay@gmail.com>
  */
 class Worker implements Runnable {
 
     private Random random = new Random();
-    private Object lock1 = new Object();
-    private Object lock2 = new Object();
+    private final Object lock1 = new Object();
+    private final Object lock2 = new Object();
     public List<Integer> list1 = new ArrayList<>();
     public List<Integer> list2 = new ArrayList<>();
 
@@ -64,21 +64,21 @@ public void stageTwo() {
 public class WorkerThreadPool {
 
     public static void main(String[] args) {
-        ExecutorService executer = Executors.newFixedThreadPool(2);//two threads, try setting by 1 to observe time
+        ExecutorService executor = Executors.newFixedThreadPool(2);//two threads, try setting by 1 to observe time
         System.out.println("Starting ...");
         long start = System.currentTimeMillis();
         Worker worker = new Worker();
         for (int i = 0; i < 2; i++) {//worker.run is called 2 (threads started) times by two threads
-            executer.submit(worker);
+            executor.submit(worker);
         }
-        executer.shutdown(); //prevents new tasks from being accepted by the ExecutorService
+        executor.shutdown(); //prevents new tasks from being accepted by the ExecutorService
         try {
-            executer.awaitTermination(1, TimeUnit.DAYS);
-            // How long should I wait for termination If I donot know exactly when threads are done with the tasks ?
+            executor.awaitTermination(1, TimeUnit.DAYS);
+            // How long should I wait for termination If I do not know exactly when threads are done with the tasks ?
             // Source:http://stackoverflow.com/questions/1250643/how-to-wait-for-all-threads-to-finish-using-executorservice
-            // For a perpetually running batch kind of thing u need to submit jobs and wait for them to 
-            // finish before jumping ahead. 
-            // In Such a case a latch or a barrier makes more sense than a shutdown (see CountDownLatch_6.App). 
+            // For a perpetually running batch kind of thing u need to submit jobs and wait for them to
+            // finish before jumping ahead.
+            // In Such a case a latch or a barrier makes more sense than a shutdown (see CountDownLatch_6.App).
         } catch (InterruptedException ex) {
             System.out.println(ex.getMessage());
         }
diff --git a/JavaMultiThreadingCodes/src/VolatileKeyword_2/App.java b/JavaMultiThreadingCodes/src/VolatileKeyword_2/App.java
index cc9ba8e..c133425 100644
--- a/JavaMultiThreadingCodes/src/VolatileKeyword_2/App.java
+++ b/JavaMultiThreadingCodes/src/VolatileKeyword_2/App.java
@@ -1,12 +1,12 @@
 package VolatileKeyword_2;
 
 /**
- * Volatile Keyword, “… the volatile modifier guarantees that any thread that
- * reads a field will see the most recently written value.” - Josh Bloch
- *
- * Codes with minor comments are from http://www.caveofprogramming.com/youtube/
+ * Volatile Keyword, <em>“… the volatile modifier guarantees that any thread that
+ * reads a field will see the most recently written value.”</em> - Josh Bloch
+ * <br><br>
+ * Codes with minor comments are from <em>http://www.caveofprogramming.com/youtube/</em><br>
  * also freely available at
- * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ * <em>https://www.udemy.com/java-multithreading/?couponCode=FREE</em>
  *
  * @author Z.B. Celik <celik.berkay@gmail.com>
  */
diff --git a/JavaMultiThreadingCodes/src/WaitAndNotify_8/App.java b/JavaMultiThreadingCodes/src/WaitAndNotify_8/App.java
index 4cc108e..f45c252 100644
--- a/JavaMultiThreadingCodes/src/WaitAndNotify_8/App.java
+++ b/JavaMultiThreadingCodes/src/WaitAndNotify_8/App.java
@@ -1,14 +1,15 @@
 package WaitAndNotify_8;
 
 /**
- * wait and notify in Java; low-level multithreading methods of the Object class
+ * {@link Object#wait()} and {@link Object#notify()} in Java; low-level
+ * multi-threading methods of the {@link java.lang.Object} class
  * that allow you to have one or more threads sleeping, only to be woken up by
  * other threads at the right moment. Extremely useful for avoiding those
  * processor-consuming "polling loops".
  *
- * Codes with minor comments are from http://www.caveofprogramming.com/youtube/
+ * Codes with minor comments are from <em>http://www.caveofprogramming.com/youtube/</em><br>
  * also freely available at
- * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ * <em>https://www.udemy.com/java-multithreading/?couponCode=FREE</em>
  *
  * @author Z.B. Celik <celik.berkay@gmail.com>
  */
@@ -21,9 +22,7 @@ public static void main(String[] args) throws InterruptedException {
             public void run() {
                 try {
                     processor.produce();
-                } catch (InterruptedException e) {
-                    e.printStackTrace();
-                }
+                } catch (InterruptedException ignored) {}
             }
         });
 
@@ -32,11 +31,10 @@ public void run() {
             public void run() {
                 try {
                     processor.consume();
-                } catch (InterruptedException e) {
-                    e.printStackTrace();
-                }
+                } catch (InterruptedException ignored) {}
             }
         });
+
         t1.start();
         t2.start();
         t1.join();
diff --git a/JavaMultiThreadingCodes/src/WaitAndNotify_8/BlockingQueueApp.java b/JavaMultiThreadingCodes/src/WaitAndNotify_8/BlockingQueueApp.java
index 23c61d8..843f7cc 100644
--- a/JavaMultiThreadingCodes/src/WaitAndNotify_8/BlockingQueueApp.java
+++ b/JavaMultiThreadingCodes/src/WaitAndNotify_8/BlockingQueueApp.java
@@ -9,34 +9,40 @@
 
 /**
  * Source:
- * http://stackoverflow.com/questions/2536692/a-simple-scenario-using-wait-and-notify-in-java
- * Firstly, you need to ensure that any calls to wait() or notify() are within a
- * synchronized region of code (with the wait() and notify() calls being
- * synchronized on the "same" object). The reason for this (other than the
- * standard thread safety concerns) is due to something known as a missed
- * signal.
- *
- * An example of this, is that a thread may call put() when the queue happens to
- * be full, it then checks the condition, sees that the queue is full, however
+ * <em>http://stackoverflow.com/questions/2536692/a-simple-scenario-using-wait-and-notify-in-java</em>
+ * <br><br>
+ * Firstly, you need to ensure that any calls to {@code wait() or notify()} are
+ * within a synchronized region of code (with the {@code wait() or notify()}
+ * calls being synchronized on the "same" object).
+ * The reason for this (other than the standard thread safety concerns) is
+ * due to something known as a missed signal.
+ * <br><br>
+ * An example of this, is that a thread may call {@link WaitAndNotify_8.BlockingQueue#put}
+ * when the queue happens to be full, it then checks the condition, sees that
+ * the queue is full, however
  * before it can block another thread is scheduled. This second thread then
- * take()'s an element from the queue, and notifies the waiting threads that the
+ * {@link WaitAndNotify_8.BlockingQueue#take()}'s an element from the queue,
+ * and notifies the waiting threads that the
  * queue is no longer full. Because the first thread has already checked the
- * condition however, it will simply call wait() after being re-scheduled, even
- * though it could make progress.
- *
+ * condition. However, it will simply call {@code wait()} after being
+ * re-scheduled, even though it could make progress.
+ * <br>
  * By synchronizing on a shared object, you can ensure that this problem does
- * not occur, as the second thread's take() call will not be able to make
- * progress until the first thread has actually blocked.
- *
+ * not occur,as the second thread's {@link WaitAndNotify_8.BlockingQueue#take()}
+ * call will not be able to make progress until the first thread has actually
+ * blocked.
+ * <br>
  * You must hold the lock (synchronized) before invoking wait/notify. Threads
  * also have to acquire lock before waking.
- *
- * More:In order to wait on an object, we must be synchronized on that object.
+ * <br><br>
+ * More: In order to wait on an object, we must be synchronized on that object.
+ * <br>
  * But our thread will automatically release the lock temporarily while waiting.
- * Calling wait() means that our thread will be suspended until it is
+ * Calling {@code wait()} means that our thread will be suspended until it is
  * "notified". Our thread will be "notified", and thus woken up, when another
- * thread calls notify() on the object that we're waiting on (in this case, the
- * connection list). When our thread wakes up, it automatically regains the
+ * thread calls {@code notify()} on the object that we're waiting on (in this
+ * case, the connection list).
+ * When our thread wakes up, it automatically regains the
  * lock. We can now check again that the list is not empty, and if it isn't,
  * safely take out the first connection. This checking and removing will be
  * atomic because we have the lock on the list.
@@ -44,7 +50,8 @@
  * @author Z.B. Celik <celik.berkay@gmail.com>
  *
  */
-//For the other version of the implementation please check LowLevelProducerConsumer_9.App
+//For the other version of the implementation please check
+// LowLevelProducerConsumer_9.App
 class BlockingQueue<T> {
 
     private Queue<T> queue = new LinkedList<>();
@@ -63,12 +70,12 @@ public void put(T element) throws InterruptedException {
         try {
             while (queue.size() == capacity) {
                 System.out.println("queue is full cannot put");
-                notFull.await();//releases lock
+                notFull.await(); //releases lock
             }
 
             queue.add(element);
             System.out.println("Added to the queue " + element);
-            notEmpty.signal();//call waiting thread on same object
+            notEmpty.signal(); //calls waiting thread on the same object
         } finally {
             lock.unlock();
         }
@@ -92,6 +99,7 @@ public T take() throws InterruptedException {
     }
 }
 
+@SuppressWarnings("InfiniteLoopStatement")
 public class BlockingQueueApp {
 
     public static void main(String[] args) throws InterruptedException {
@@ -103,9 +111,7 @@ public void run() {
                     while (true) {
                         blockingQueue.put(random.nextInt(10));
                     }
-                } catch (InterruptedException e) {
-                    e.printStackTrace();
-                }
+                } catch (InterruptedException ignored) {}
             }
         });
 
@@ -120,9 +126,7 @@ public void run() {
                     while (true) {
                         blockingQueue.take();
                     }
-                } catch (InterruptedException e) {
-                    e.printStackTrace();
-                }
+                } catch (InterruptedException ignored) {}
             }
         });
         t1.start();
diff --git a/JavaMultiThreadingCodes/src/WaitAndNotify_8/Processor.java b/JavaMultiThreadingCodes/src/WaitAndNotify_8/Processor.java
index bf4ca1a..18e965d 100644
--- a/JavaMultiThreadingCodes/src/WaitAndNotify_8/Processor.java
+++ b/JavaMultiThreadingCodes/src/WaitAndNotify_8/Processor.java
@@ -3,31 +3,42 @@
 import java.util.Scanner;
 
 /**
- * Some background knowledge
- * Source:http://www.programcreek.com/2009/02/notify-and-wait-example/
- * synchronized keyword is used for exclusive accessing. To make a method
- * synchronized, simply add the synchronized keyword to its declaration. Then no
- * two invocations of synchronized methods on the same object can interleave
- * with each other. Synchronized statements must specify the object that
- * provides the intrinsic lock. When synchronized(this) is used, you have to
- * avoid to synchronizing invocations of other objects' methods. wait() tells
+ * Some background knowledge<br>
+ * Source: <em>http://www.programcreek.com/2009/02/notify-and-wait-example/</em>
+ * <br><br>
+ * {@code synchronized} keyword is used for exclusive accessing. To make a
+ * method {@code synchronized}, simply add the {@code synchronized} keyword to its
+ * declaration.<be>
+ * Then no two invocations of synchronized methods on the same object can
+ * interleave with each other.
+ * <br>
+ * Synchronized statements must specify the object that
+ * provides the intrinsic lock. When {@code synchronized(this)} is used, you
+ * have to avoid to synchronizing invocations of other objects' methods.
+ * <br>
+ * {@link Object#wait()} tells
  * the calling thread to give up the lock and go to sleep (not polling) until
- * some other thread enters the same lock and calls notify(). notify() wakes up
- * the first thread that called wait() on the same object.
- *
- * Codes with minor comments are from http://www.caveofprogramming.com/youtube/
+ * some other thread enters the same lock and calls {@link Object#notify()}.
+ * <br>
+ * {@link Object#notify()} wakes up the first thread that called wait() on
+ * the same object.
+ * <br><br>
+ * Codes with minor comments are from <em>http://www.caveofprogramming.com/youtube/</em><br>
  * also freely available at
- * https://www.udemy.com/java-multithreading/?couponCode=FREE
+ * <em>https://www.udemy.com/java-multithreading/?couponCode=FREE</em>
  *
  * @author Z.B. Celik <celik.berkay@gmail.com>
  */
 public class Processor {
 
-    /**
+    /*
      * public synchronized void getSomething(){ this.hello = "hello World"; }
      * public void getSomething(){ synchronized(this){ this.hello = "hello
-     * World"; } , two code blocks by specification, functionally identical.
+     * World"; } }
+     * two code blocks by specification, functionally identical.
      */
+
+
     public void produce() throws InterruptedException {
         synchronized (this) {
             System.out.println("Producer thread running ....");
@@ -45,6 +56,7 @@ public void consume() throws InterruptedException {
             System.out.println("Return key pressed.");
             notify();
             Thread.sleep(5000);
+            System.out.println("Consumption done.");
         }
     }
 }