Simplify code

Author: winterbe

src/com/winterbe/java8/samples/concurrent/ConcurrentUtils.java

@@ -24,4 +24,12 @@ public static void stop(ExecutorService executor) {
         }
     }
 
+    public static void sleep(int seconds) {
+        try {
+            TimeUnit.SECONDS.sleep(seconds);
+        } catch (InterruptedException e) {
+            throw new IllegalStateException(e);
+        }
+    }
+
 }

src/com/winterbe/java8/samples/concurrent/Lock1.java

@@ -20,8 +20,7 @@ private static void increment() {
         lock.lock();
         try {
             count++;
-        }
-        finally {
+        } finally {
             lock.unlock();
         }
     }
@@ -36,7 +35,7 @@ private static void testLock() {
         ExecutorService executor = Executors.newFixedThreadPool(2);
 
         IntStream.range(0, NUM_INCREMENTS)
-                .forEach(i -> executor.submit(Lock1::increment));
+                 .forEach(i -> executor.submit(Lock1::increment));
 
         ConcurrentUtils.stop(executor);
 

src/com/winterbe/java8/samples/concurrent/Lock2.java

@@ -2,7 +2,6 @@
 
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
-import java.util.concurrent.TimeUnit;
 import java.util.concurrent.locks.ReentrantLock;
 
 /**
@@ -18,9 +17,7 @@ public static void main(String[] args) {
         executor.submit(() -> {
             lock.lock();
             try {
-                TimeUnit.SECONDS.sleep(1);
-            } catch (InterruptedException e) {
-                throw new IllegalStateException(e);
+                ConcurrentUtils.sleep(1);
             } finally {
                 lock.unlock();
             }

src/com/winterbe/java8/samples/concurrent/Lock3.java

@@ -4,7 +4,6 @@
 import java.util.Map;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
-import java.util.concurrent.TimeUnit;
 import java.util.concurrent.locks.ReadWriteLock;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 
@@ -23,10 +22,8 @@ public static void main(String[] args) {
         executor.submit(() -> {
             lock.writeLock().lock();
             try {
-                TimeUnit.SECONDS.sleep(1);
+                ConcurrentUtils.sleep(1);
                 map.put("foo", "bar");
-            } catch (InterruptedException e) {
-                throw new IllegalStateException(e);
             } finally {
                 lock.writeLock().unlock();
             }
@@ -36,9 +33,7 @@ public static void main(String[] args) {
             lock.readLock().lock();
             try {
                 System.out.println(map.get("foo"));
-                TimeUnit.SECONDS.sleep(1);
-            } catch (InterruptedException e) {
-                throw new IllegalStateException(e);
+                ConcurrentUtils.sleep(1);
             } finally {
                 lock.readLock().unlock();
             }

src/com/winterbe/java8/samples/concurrent/Lock4.java

@@ -4,7 +4,6 @@
 import java.util.Map;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
-import java.util.concurrent.TimeUnit;
 import java.util.concurrent.locks.StampedLock;
 
 /**
@@ -22,10 +21,8 @@ public static void main(String[] args) {
         executor.submit(() -> {
             long stamp = lock.writeLock();
             try {
-                TimeUnit.SECONDS.sleep(1);
+                ConcurrentUtils.sleep(1);
                 map.put("foo", "bar");
-            } catch (InterruptedException e) {
-                throw new IllegalStateException(e);
             } finally {
                 lock.unlockWrite(stamp);
             }
@@ -35,9 +32,7 @@ public static void main(String[] args) {
             long stamp = lock.readLock();
             try {
                 System.out.println(map.get("foo"));
-                TimeUnit.SECONDS.sleep(1);
-            } catch (InterruptedException e) {
-                throw new IllegalStateException(e);
+                ConcurrentUtils.sleep(1);
             } finally {
                 lock.unlockRead(stamp);
             }

src/com/winterbe/java8/samples/concurrent/Lock5.java

@@ -2,16 +2,13 @@
 
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
-import java.util.concurrent.TimeUnit;
 import java.util.concurrent.locks.StampedLock;
 
 /**
  * @author Benjamin Winterberg
  */
 public class Lock5 {
 
-    private static int count = 0;
-
     public static void main(String[] args) {
         ExecutorService executor = Executors.newFixedThreadPool(2);
 
@@ -21,10 +18,8 @@ public static void main(String[] args) {
             long stamp = lock.tryOptimisticRead();
             try {
                 System.out.println("Optimistic Lock Valid: " + lock.validate(stamp));
-                TimeUnit.SECONDS.sleep(1);
+                ConcurrentUtils.sleep(1);
                 System.out.println("Optimistic Lock Valid: " + lock.validate(stamp));
-            } catch (InterruptedException e) {
-                throw new IllegalStateException(e);
             } finally {
                 lock.unlock(stamp);
             }
@@ -34,23 +29,14 @@ public static void main(String[] args) {
             long stamp = lock.writeLock();
             try {
                 System.out.println("Write Lock acquired");
-                incrementAndSleep(2);
+                ConcurrentUtils.sleep(2);
             } finally {
                 lock.unlock(stamp);
                 System.out.println("Write done");
             }
         });
 
-
         ConcurrentUtils.stop(executor);
     }
 
-    private static void incrementAndSleep(int sleepSeconds) {
-        try {
-            count++;
-            TimeUnit.SECONDS.sleep(sleepSeconds);
-        } catch (InterruptedException e) {
-            throw new IllegalStateException(e);
-        }
-    }
 }