From d8658f0a522b5a92fbd58369c904c2a28a496abe Mon Sep 17 00:00:00 2001 From: Bruce Eckel Date: Wed, 18 Jan 2017 16:10:15 -0800 Subject: [PATCH] Final pass-through edits --- concurrent/DiningPhilosophers.java | 11 +++------ concurrent/SharedConstructorArgument.java | 2 +- concurrent/SynchronizedConstructor.java | 6 +++-- concurrent/SynchronizedFactory.java | 29 +++++++++++++++++++++++ lowlevel/ReOrdering.java | 19 +++++++++++++++ lowlevel/SettingDefaultHandler.java | 3 ++- lowlevel/SynchronizedComparison.java | 8 +++---- 7 files changed, 61 insertions(+), 17 deletions(-) create mode 100644 concurrent/SynchronizedFactory.java create mode 100644 lowlevel/ReOrdering.java diff --git a/concurrent/DiningPhilosophers.java b/concurrent/DiningPhilosophers.java index bc3154ca..942779e7 100644 --- a/concurrent/DiningPhilosophers.java +++ b/concurrent/DiningPhilosophers.java @@ -5,7 +5,7 @@ // Hidden deadlock import java.util.*; import java.util.concurrent.*; -import static java.util.concurrent.TimeUnit.*; +import onjava.Nap; public class DiningPhilosophers { private StickHolder[] sticks; @@ -17,7 +17,7 @@ public class DiningPhilosophers { Arrays.setAll(philosophers, i -> new Philosopher(i, sticks[i], sticks[(i + 1) % n])); // [1] - // Fix by reversing stick order: + // Fix by reversing stick order for this one: // philosophers[1] = // [2] // new Philosopher(0, sticks[0], sticks[1]); Arrays.stream(philosophers) @@ -27,11 +27,6 @@ public class DiningPhilosophers { // Returns right away: new DiningPhilosophers(5); // [4] // Keeps main() from exiting: - ScheduledExecutorService sched = - Executors.newScheduledThreadPool(1); - sched.schedule( () -> { - System.out.println("Shutdown"); - sched.shutdown(); - }, 3, SECONDS); + new Nap(3000, "Shutdown"); } } diff --git a/concurrent/SharedConstructorArgument.java b/concurrent/SharedConstructorArgument.java index 8de1e70b..b49f857a 100644 --- a/concurrent/SharedConstructorArgument.java +++ b/concurrent/SharedConstructorArgument.java @@ -17,7 +17,7 @@ class Safe implements SharedArg { private static AtomicInteger counter = new AtomicInteger(); public int get() { - return counter.getAndAdd(1); + return counter.getAndIncrement(); } } diff --git a/concurrent/SynchronizedConstructor.java b/concurrent/SynchronizedConstructor.java index 300a9d15..0533f8bb 100644 --- a/concurrent/SynchronizedConstructor.java +++ b/concurrent/SynchronizedConstructor.java @@ -6,7 +6,8 @@ import java.util.concurrent.atomic.*; class SyncConstructor implements HasID { private final int id; - private static Object constructorLock = new Object(); + private static Object + constructorLock = new Object(); public SyncConstructor(SharedArg sa) { synchronized(constructorLock) { id = sa.get(); @@ -19,7 +20,8 @@ class SyncConstructor implements HasID { public class SynchronizedConstructor { public static void main(String[] args) { Unsafe unsafe = new Unsafe(); - IDChecker.test(() -> new SyncConstructor(unsafe)); + IDChecker.test(() -> + new SyncConstructor(unsafe)); } } /* Output: diff --git a/concurrent/SynchronizedFactory.java b/concurrent/SynchronizedFactory.java new file mode 100644 index 00000000..d16d3a3e --- /dev/null +++ b/concurrent/SynchronizedFactory.java @@ -0,0 +1,29 @@ +// concurrent/SynchronizedFactory.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.*; + +class SyncFactory implements HasID { + private final int id; + private SyncFactory(SharedArg sa) { + id = sa.get(); + } + @Override + public int getID() { return id; } + public static synchronized + SyncFactory factory(SharedArg sa) { + return new SyncFactory(sa); + } +} + +public class SynchronizedFactory { + public static void main(String[] args) { + Unsafe unsafe = new Unsafe(); + IDChecker.test(() -> + SyncFactory.factory(unsafe)); + } +} +/* Output: +0 +*/ diff --git a/lowlevel/ReOrdering.java b/lowlevel/ReOrdering.java new file mode 100644 index 00000000..9de9c4b8 --- /dev/null +++ b/lowlevel/ReOrdering.java @@ -0,0 +1,19 @@ +// lowlevel/ReOrdering.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. + +public class ReOrdering implements Runnable { + int one, two, three, four, five, six; + volatile int volaTile; + @Override + public void run() { + one = 1; + two = 2; + three = 3; + volaTile = 92; + int x = four; + int y = five; + int z = six; + } +} diff --git a/lowlevel/SettingDefaultHandler.java b/lowlevel/SettingDefaultHandler.java index ac50eaf4..9b13362b 100644 --- a/lowlevel/SettingDefaultHandler.java +++ b/lowlevel/SettingDefaultHandler.java @@ -8,7 +8,8 @@ public class SettingDefaultHandler { public static void main(String[] args) { Thread.setDefaultUncaughtExceptionHandler( new MyUncaughtExceptionHandler()); - ExecutorService es = Executors.newCachedThreadPool(); + ExecutorService es = + Executors.newCachedThreadPool(); es.execute(new ExceptionThread()); es.shutdown(); } diff --git a/lowlevel/SynchronizedComparison.java b/lowlevel/SynchronizedComparison.java index 20333801..62a38305 100644 --- a/lowlevel/SynchronizedComparison.java +++ b/lowlevel/SynchronizedComparison.java @@ -43,13 +43,11 @@ class Caller implements Runnable { new AtomicLong(); private AtomicBoolean stop = new AtomicBoolean(false); - class Stop extends TimerTask { - @Override - public void run() { stop.set(true); } - } @Override public void run() { - new Timer().schedule(new Stop(), 2500); + new Timer().schedule(new TimerTask() { + public void run() { stop.set(true); } + }, 2500); while(!stop.get()) { g.method(); successfulCalls.getAndIncrement();