JavaDoc optimized for packages 7.8.9

IOAyman · IOAyman · commit 52628e5594f9 · 2015-01-11T17:56:56.000+01:00
Suppress inspection Warnings about infinite loop statements
diff --git 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
@@ -1,15 +1,16 @@
 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<>();
diff --git a/JavaMultiThreadingCodes/src/ProducerConsumer_7/App.java b/JavaMultiThreadingCodes/src/ProducerConsumer_7/App.java
@@ -18,6 +18,7 @@
 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.BlockingQueue;
 
+@SuppressWarnings("InfiniteLoopStatement")
 public class App {
 
     /**
@@ -57,7 +58,8 @@ public void run() {
 //        t1.join();
 //        t2.join();
 
-        // Pause for 30 seconds and force quitting the app (because we're looping infinitely)
+        // 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/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
@@ -98,6 +98,7 @@ public T take() throws InterruptedException {
     }
 }
 
+@SuppressWarnings("InfiniteLoopStatement")
 public class BlockingQueueApp {
 
     public static void main(String[] args) throws InterruptedException {
@@ -109,9 +110,7 @@ public void run() {
                     while (true) {
                         blockingQueue.put(random.nextInt(10));
                     }
-                } catch (InterruptedException e) {
-                    e.printStackTrace();
-                }
+                } catch (InterruptedException ignored) {}
             }
         });
 
@@ -126,9 +125,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
@@ -3,32 +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.
      */
+
+
     public void produce() throws InterruptedException {
         synchronized (this) {
             System.out.println("Producer thread running ....");

Original file line number	Diff line number	Diff line change
`@@ -98,6 +98,7 @@ public T take() throws InterruptedException {`
`98`	`98`	`}`
`99`	`99`	`}`
`100`	`100`
	`101`	`+@SuppressWarnings("InfiniteLoopStatement")`
`101`	`102`	`public class BlockingQueueApp {`
`102`	`103`
`103`	`104`	`public static void main(String[] args) throws InterruptedException {`
`@@ -109,9 +110,7 @@ public void run() {`
`109`	`110`	`while (true) {`
`110`	`111`	`blockingQueue.put(random.nextInt(10));`
`111`	`112`	`}`
`112`		`- } catch (InterruptedException e) {`
`113`		`- e.printStackTrace();`
`114`		`- }`
	`113`	`+ } catch (InterruptedException ignored) {}`
`115`	`114`	`}`
`116`	`115`	`});`
`117`	`116`
`@@ -126,9 +125,7 @@ public void run() {`
`126`	`125`	`while (true) {`
`127`	`126`	`blockingQueue.take();`
`128`	`127`	`}`
`129`		`- } catch (InterruptedException e) {`
`130`		`- e.printStackTrace();`
`131`		`- }`
	`128`	`+ } catch (InterruptedException ignored) {}`
`132`	`129`	`}`
`133`	`130`	`});`
`134`	`131`	`t1.start();`