Did a first code inspection tour

IOAyman · IOAyman · commit 460eb93a27e2 · 2015-01-09T09:37:23.000+01:00
Corrected some typos
Emptied some auto-generated catch sections and renamed the exception variable to "ignored"
diff --git 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
@@ -45,10 +45,7 @@ public void run() {
 
         try {
             Thread.sleep(3000);
-        } catch (InterruptedException e) {
-            // TODO Auto-generated catch block
-            e.printStackTrace();
-        }
+        } catch (InterruptedException ignored) {}
         latch.countDown();
     }
 }
@@ -62,7 +59,7 @@ public static void main(String[] args) {
             executor.submit(new Processor(latch));
         }
         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
@@ -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
@@ -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
@@ -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
@@ -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/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
@@ -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/Processor.java b/JavaMultiThreadingCodes/src/LowLevelProducerConsumer_9/Processor.java
@@ -14,13 +14,13 @@ 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/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
@@ -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
@@ -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/ThreadPools_5/App.java b/JavaMultiThreadingCodes/src/ThreadPools_5/App.java
@@ -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
@@ -19,8 +19,8 @@
 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());
         }

Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@`
`18`	`18`	`* Runnable Introduced in Java 1.0 Callable<T> Introduced in Java 1.5 as part of`
`19`	`19`	`* java.util.concurrent library`
`20`	`20`	`*`
`21`		`- * Runnable cannot be parameterized Callable is a parameterized type whose type`
	`21`	`+ * Runnable cannot be parametrized Callable is a parametrized type whose type`
`22`	`22`	`* parameter indicates the return type of its run method Classes implementing`
`23`	`23`	`*`
`24`	`24`	`* Runnable needs to implement run() method, classes implementing Callable needs`
Original file line number	Diff line number	Diff line change
`@@ -45,10 +45,7 @@ public void run() {`
`45`	`45`
`46`	`46`	`try {`
`47`	`47`	`Thread.sleep(3000);`
`48`		`- } catch (InterruptedException e) {`
`49`		`- // TODO Auto-generated catch block`
`50`		`- e.printStackTrace();`
`51`		`- }`
	`48`	`+ } catch (InterruptedException ignored) {}`
`52`	`49`	`latch.countDown();`
`53`	`50`	`}`
`54`	`51`	`}`
`@@ -62,7 +59,7 @@ public static void main(String[] args) {`
`62`	`59`	`executor.submit(new Processor(latch));`
`63`	`60`	`}`
`64`	`61`	`try {`
`65`		`- // Application’s main thread waits, till other service threads which are`
	`62`	`+ // Application’s main thread waits, till other service threads which are`
`66`	`63`	`// as an example responsible for starting framework services have completed started all services.`
`67`	`64`	`latch.await();`
`68`	`65`	`} catch (InterruptedException e) {`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ private void acquireLocks(Lock firstLock, Lock secondLock) throws InterruptedExc`
`53`	`53`	`}`
`54`	`54`	`}`
`55`	`55`
`56`		`- //firstThreaad runs`
	`56`	`+ //firstThread runs`
`57`	`57`	`public void firstThread() throws InterruptedException {`
`58`	`58`	`Random random = new Random();`
`59`	`59`	`for (int i = 0; i < 10000; i++) {`
Original file line number	Diff line number	Diff line change
`@@ -70,10 +70,7 @@ public void run() {`
`70`	`70`	`try {`
`71`	`71`	`thread1.join();`
`72`	`72`	`thread2.join();`
`73`		`- } catch (InterruptedException e) {`
`74`		`- // TODO Auto-generated catch block`
`75`		`- e.printStackTrace();`
`76`		`- }`
	`73`	`+ } catch (InterruptedException ignored) {}`
`77`	`74`	`System.out.println("Count is: " + count);`
`78`	`75`	`}`
`79`	`76`	`}`