Went back and optimized the JavaDoc for all the packages up till the 8th one (breaks, italics, class/package references ..etc), so it looks prettier when integrated to the IDE.

IOAyman · IOAyman · commit b65b85e19c4b · 2015-01-09T12:21:55.000+01:00
diff --git 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>
  */
diff --git 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>
  */
diff --git 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/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>
  */
@@ -19,14 +21,16 @@
 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);
diff --git 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>
  */
diff --git 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
@@ -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
@@ -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>
  */
diff --git a/JavaMultiThreadingCodes/src/ThreadPools_5/WorkerThreadPool.java b/JavaMultiThreadingCodes/src/ThreadPools_5/WorkerThreadPool.java
@@ -8,11 +8,11 @@
 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>
  */
diff --git 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/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.
diff --git a/JavaMultiThreadingCodes/src/WaitAndNotify_8/Processor.java b/JavaMultiThreadingCodes/src/WaitAndNotify_8/Processor.java
@@ -26,7 +26,8 @@ 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) {
@@ -45,6 +46,7 @@ public void consume() throws InterruptedException {
             System.out.println("Return key pressed.");
             notify();
             Thread.sleep(5000);
+            System.out.println("Consumption done.");
         }
     }
 }
