Name changes and new TimedAbort

Bruce Eckel · Bruce Eckel · commit 8833d2e228a6 · 2017-01-11T16:18:57.000-08:00
diff --git a/lowlevel/AtomicEvenProducer.java b/lowlevel/AtomicEvenProducer.java
@@ -1,21 +1,19 @@
-// lowlevel/AtomicEvenSupplier.java
+// lowlevel/AtomicEvenProducer.java
 // (c)2017 MindView LLC: see Copyright.txt
 // We make no guarantees that this code is fit for any purpose.
 // Visit http://OnJava8.com for more book information.
 // Atomic classes are occasionally useful in regular code
 // {IgnoreOutput} // No output validation
 import java.util.concurrent.atomic.*;
-import onjava.TimedAbort;
 
-public class AtomicEvenSupplier extends IntSupplier {
+public class AtomicEvenProducer extends IntGenerator {
   private AtomicInteger currentEvenValue =
     new AtomicInteger(0);
   @Override
   public int next() {
     return currentEvenValue.addAndGet(2);
   }
   public static void main(String[] args) {
-    new TimedAbort(4);
-    EvenChecker.test(new AtomicEvenSupplier());
+    EvenChecker.test(new AtomicEvenProducer());
   }
 }
diff --git a/lowlevel/EvenChecker.java b/lowlevel/EvenChecker.java
@@ -3,13 +3,14 @@
 // We make no guarantees that this code is fit for any purpose.
 // Visit http://OnJava8.com for more book information.
 import java.util.concurrent.*;
+import onjava.TimedAbort;
 
 public class EvenChecker implements Runnable {
-  private IntSupplier generator;
+  private IntGenerator generator;
   private final int id;
-  public EvenChecker(IntSupplier g, int ident) {
-    generator = g;
-    id = ident;
+  public EvenChecker(IntGenerator generator, int id) {
+    this.generator = generator;
+    this.id = id;
   }
   @Override
   public void run() {
@@ -21,16 +22,17 @@ public void run() {
       }
     }
   }
-  // Test any type of IntSupplier:
-  public static void test(IntSupplier gp, int count) {
+  // Test any IntGenerator:
+  public static void test(IntGenerator gp, int count) {
     System.out.println("Press Control-C to exit");
     ExecutorService es = Executors.newCachedThreadPool();
     for(int i = 0; i < count; i++)
       es.execute(new EvenChecker(gp, i));
     es.shutdown();
   }
   // Default value for count:
-  public static void test(IntSupplier gp) {
+  public static void test(IntGenerator gp) {
+    new TimedAbort(4);
     test(gp, 10);
   }
 }
diff --git a/lowlevel/EvenProducer.java b/lowlevel/EvenProducer.java
@@ -1,26 +1,25 @@
-// lowlevel/EvenSupplier.java
+// lowlevel/EvenProducer.java
 // (c)2017 MindView LLC: see Copyright.txt
 // We make no guarantees that this code is fit for any purpose.
 // Visit http://OnJava8.com for more book information.
 // When threads collide
-import onjava.TimedAbort;
 
-public class EvenSupplier extends IntSupplier {
+public class EvenProducer extends IntGenerator {
   private int currentEvenValue = 0;
   @Override
   public int next() {
-    ++currentEvenValue; // Danger point here!
+    ++currentEvenValue; // [1]
     ++currentEvenValue;
     return currentEvenValue;
   }
   public static void main(String[] args) {
-    new TimedAbort(4);
-    EvenChecker.test(new EvenSupplier());
+    EvenChecker.test(new EvenProducer());
   }
 }
 /* Output:
 Press Control-C to exit
-193 not even!
-191 not even!
-TimedAbort 4
+841 not even!
+847 not even!
+845 not even!
+843 not even!
 */
diff --git a/lowlevel/ExceptionThread.java b/lowlevel/ExceptionThread.java
@@ -12,7 +12,8 @@ public void run() {
     throw new RuntimeException();
   }
   public static void main(String[] args) {
-    ExecutorService es = Executors.newCachedThreadPool();
+    ExecutorService es =
+      Executors.newCachedThreadPool();
     es.execute(new ExceptionThread());
     es.shutdown();
   }
diff --git a/lowlevel/IntGenerator.java b/lowlevel/IntGenerator.java
@@ -0,0 +1,15 @@
+// lowlevel/IntGenerator.java
+// (c)2017 MindView LLC: see Copyright.txt
+// We make no guarantees that this code is fit for any purpose.
+// Visit http://OnJava8.com for more book information.
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public abstract class IntGenerator {
+  private AtomicBoolean canceled =
+    new AtomicBoolean();
+  public abstract int next();
+  public void cancel() { canceled.set(true); }
+  public boolean isCanceled() {
+    return canceled.get();
+  }
+}
diff --git a/lowlevel/IntSupplier.java b/lowlevel/IntSupplier.java
diff --git a/lowlevel/MutexEvenProducer.java b/lowlevel/MutexEvenProducer.java
@@ -1,13 +1,12 @@
-// lowlevel/MutexEvenSupplier.java
+// lowlevel/MutexEvenProducer.java
 // (c)2017 MindView LLC: see Copyright.txt
 // We make no guarantees that this code is fit for any purpose.
 // Visit http://OnJava8.com for more book information.
 // Preventing thread collisions with mutexes
 // {IgnoreOutput} // No output validation
 import java.util.concurrent.locks.*;
-import onjava.TimedAbort;
 
-public class MutexEvenSupplier extends IntSupplier {
+public class MutexEvenProducer extends IntGenerator {
   private int currentEvenValue = 0;
   private Lock lock = new ReentrantLock();
   @Override
@@ -23,7 +22,6 @@ public int next() {
     }
   }
   public static void main(String[] args) {
-    new TimedAbort(4);
-    EvenChecker.test(new MutexEvenSupplier());
+    EvenChecker.test(new MutexEvenProducer());
   }
 }
diff --git a/lowlevel/SynchronizedEvenProducer.java b/lowlevel/SynchronizedEvenProducer.java
@@ -1,23 +1,22 @@
-// lowlevel/SynchronizedEvenSupplier.java
+// lowlevel/SynchronizedEvenProducer.java
 // (c)2017 MindView LLC: see Copyright.txt
 // We make no guarantees that this code is fit for any purpose.
 // Visit http://OnJava8.com for more book information.
 // Simplifying mutexes with the synchronized keyword
 // {IgnoreOutput} // No output validation
-import onjava.TimedAbort;
+import onjava.Nap;
 
 public class
-SynchronizedEvenSupplier extends IntSupplier {
+SynchronizedEvenProducer extends IntGenerator {
   private int currentEvenValue = 0;
   @Override
   public synchronized int next() {
     ++currentEvenValue;
-    Thread.yield(); // Cause failure faster
+    new Nap(10); // Cause failure faster
     ++currentEvenValue;
     return currentEvenValue;
   }
   public static void main(String[] args) {
-    new TimedAbort(4);
-    EvenChecker.test(new SynchronizedEvenSupplier());
+    EvenChecker.test(new SynchronizedEvenProducer());
   }
 }
diff --git a/lowlevel/TestAbort.java b/lowlevel/TestAbort.java
@@ -0,0 +1,17 @@
+// lowlevel/TestAbort.java
+// (c)2017 MindView LLC: see Copyright.txt
+// We make no guarantees that this code is fit for any purpose.
+// Visit http://OnJava8.com for more book information.
+import onjava.*;
+
+public class TestAbort {
+  public static void main(String[] args) {
+    new TimedAbort(1);
+    System.out.println("Napping for 4");
+    new Nap(4000);
+  }
+}
+/* Output:
+Napping for 4
+TimedAbort 1
+*/
diff --git a/lowlevel/WorkStealingPool.java b/lowlevel/WorkStealingPool.java
@@ -2,6 +2,7 @@
 // (c)2017 MindView LLC: see Copyright.txt
 // We make no guarantees that this code is fit for any purpose.
 // Visit http://OnJava8.com for more book information.
+import java.util.stream.*;
 import java.util.concurrent.*;
 
 class ShowThread implements Runnable {
@@ -19,8 +20,9 @@ public static void main(String[] args)
       Runtime.getRuntime().availableProcessors());
     ExecutorService exec =
       Executors.newWorkStealingPool();
-    for(int i = 0; i < 10; i++)
-      exec.execute(new ShowThread());
+    IntStream.range(0, 10)
+      .mapToObj(n -> new ShowThread())
+      .forEach(exec::execute);
     exec.awaitTermination(1, TimeUnit.SECONDS);
   }
 }
diff --git a/onjava/TimedAbort.java b/onjava/TimedAbort.java
@@ -4,16 +4,14 @@
 // Visit http://OnJava8.com for more book information.
 // Terminate a program after n seconds
 package onjava;
-import java.util.*;
+import java.util.concurrent.*;
 
 public class TimedAbort {
   public TimedAbort(int n) {
-    new java.util.Timer().schedule(new TimerTask() {
-      @Override
-      public void run() {
-        System.out.println("TimedAbort " + n);
-        System.exit(0);
-      }
-    }, n * 1000);
+    CompletableFuture.runAsync(() -> {
+      new Nap(1000 * n);
+      System.out.println("TimedAbort " + n);
+      System.exit(0);
+    });
   }
 }

Original file line number	Diff line number	Diff line change
`@@ -3,13 +3,14 @@`
`3`	`3`	`// We make no guarantees that this code is fit for any purpose.`
`4`	`4`	`// Visit http://OnJava8.com for more book information.`
`5`	`5`	`import java.util.concurrent.*;`
	`6`	`+import onjava.TimedAbort;`
`6`	`7`
`7`	`8`	`public class EvenChecker implements Runnable {`
`8`		`- private IntSupplier generator;`
	`9`	`+ private IntGenerator generator;`
`9`	`10`	`private final int id;`
`10`		`- public EvenChecker(IntSupplier g, int ident) {`
`11`		`- generator = g;`
`12`		`- id = ident;`
	`11`	`+ public EvenChecker(IntGenerator generator, int id) {`
	`12`	`+ this.generator = generator;`
	`13`	`+ this.id = id;`
`13`	`14`	`}`
`14`	`15`	`@Override`
`15`	`16`	`public void run() {`
`@@ -21,16 +22,17 @@ public void run() {`
`21`	`22`	`}`
`22`	`23`	`}`
`23`	`24`	`}`
`24`		`- // Test any type of IntSupplier:`
`25`		`- public static void test(IntSupplier gp, int count) {`
	`25`	`+ // Test any IntGenerator:`
	`26`	`+ public static void test(IntGenerator gp, int count) {`
`26`	`27`	`System.out.println("Press Control-C to exit");`
`27`	`28`	`ExecutorService es = Executors.newCachedThreadPool();`
`28`	`29`	`for(int i = 0; i < count; i++)`
`29`	`30`	`es.execute(new EvenChecker(gp, i));`
`30`	`31`	`es.shutdown();`
`31`	`32`	`}`
`32`	`33`	`// Default value for count:`
`33`		`- public static void test(IntSupplier gp) {`
	`34`	`+ public static void test(IntGenerator gp) {`
	`35`	`+ new TimedAbort(4);`
`34`	`36`	`test(gp, 10);`
`35`	`37`	`}`
`36`	`38`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,8 @@ public void run() {`
`12`	`12`	`throw new RuntimeException();`
`13`	`13`	`}`
`14`	`14`	`public static void main(String[] args) {`
`15`		`- ExecutorService es = Executors.newCachedThreadPool();`
	`15`	`+ ExecutorService es =`
	`16`	`+ Executors.newCachedThreadPool();`
`16`	`17`	`es.execute(new ExceptionThread());`
`17`	`18`	`es.shutdown();`
`18`	`19`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,13 +1,12 @@`
`1`		`-// lowlevel/MutexEvenSupplier.java`
	`1`	`+// lowlevel/MutexEvenProducer.java`
`2`	`2`	`// (c)2017 MindView LLC: see Copyright.txt`
`3`	`3`	`// We make no guarantees that this code is fit for any purpose.`
`4`	`4`	`// Visit http://OnJava8.com for more book information.`
`5`	`5`	`// Preventing thread collisions with mutexes`
`6`	`6`	`// {IgnoreOutput} // No output validation`
`7`	`7`	`import java.util.concurrent.locks.*;`
`8`		`-import onjava.TimedAbort;`
`9`	`8`
`10`		`-public class MutexEvenSupplier extends IntSupplier {`
	`9`	`+public class MutexEvenProducer extends IntGenerator {`
`11`	`10`	`private int currentEvenValue = 0;`
`12`	`11`	`private Lock lock = new ReentrantLock();`
`13`	`12`	`@Override`
`@@ -23,7 +22,6 @@ public int next() {`
`23`	`22`	`}`
`24`	`23`	`}`
`25`	`24`	`public static void main(String[] args) {`
`26`		`- new TimedAbort(4);`
`27`		`- EvenChecker.test(new MutexEvenSupplier());`
	`25`	`+ EvenChecker.test(new MutexEvenProducer());`
`28`	`26`	`}`
`29`	`27`	`}`