JavaDoc optimized for packages 10

Author: IOAyman

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 <[email protected]>
  */
@@ -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) {
                 }
             }
         });

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 <[email protected]>
  */
-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();
         }
     }
 

JavaMultiThreadingCodes/src/WaitAndNotify_8/BlockingQueueApp.java

@@ -50,7 +50,8 @@
  * @author Z.B. Celik <[email protected]>
  *
  */
-//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<>();
@@ -69,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();
         }