Some cleanups during rewrite

BruceEckel · BruceEckel · commit bc786ef438f4 · 2017-01-12T11:15:03.000-08:00
diff --git a/lowlevel/AttemptLocking.java b/lowlevel/AttemptLocking.java
@@ -6,6 +6,7 @@
 // to give up on trying to acquire a lock
 import java.util.concurrent.*;
 import java.util.concurrent.locks.*;
+import onjava.Nap;
 
 public class AttemptLocking {
   private ReentrantLock lock = new ReentrantLock();
@@ -46,7 +47,7 @@ public void run() {
         System.out.println("acquired");
       }
     }.start();
-    Thread.yield(); // Give the 2nd task a chance
+    new Nap(10);  // Give the 2nd task a chance
     al.untimed(); // False -- lock grabbed by task
     al.timed();   // False -- lock grabbed by task
   }
diff --git a/lowlevel/CriticalSection.java b/lowlevel/CriticalSection.java
@@ -2,12 +2,9 @@
 // (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.
-// (Behavior may have changed in Java 8)
 // Synchronizing blocks instead of entire methods. Also
 // demonstrates protection of a non-thread-safe class
 // with a thread-safe one.
-// {java lowlevel.CriticalSection}
-package lowlevel;
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.*;
 import java.util.*;
diff --git a/lowlevel/ExplicitCriticalSection.java b/lowlevel/ExplicitCriticalSection.java
diff --git a/lowlevel/MutexEvenProducer.java b/lowlevel/MutexEvenProducer.java
@@ -5,6 +5,7 @@
 // Preventing thread collisions with mutexes
 // {IgnoreOutput} // No output validation
 import java.util.concurrent.locks.*;
+import onjava.Nap;
 
 public class MutexEvenProducer extends IntGenerator {
   private int currentEvenValue = 0;
@@ -14,7 +15,7 @@ public int next() {
     lock.lock();
     try {
       ++currentEvenValue;
-      Thread.yield(); // Cause failure faster
+      new Nap(10); // Cause failure faster
       ++currentEvenValue;
       return currentEvenValue;
     } finally {
diff --git a/lowlevel/PriorityBlockingQueueDemo.java b/lowlevel/PriorityBlockingQueueDemo.java
@@ -73,7 +73,7 @@ public void run() {
     // Fill it up fast with random priorities:
     for(int i = 0; i < 20; i++) {
       queue.add(new PrioritizedTask(rand.nextInt(10)));
-      Thread.yield();
+      new Nap(10);
     }
     // Trickle in highest-priority jobs:
     for(int i = 0; i < 10; i++) {
diff --git a/lowlevel/SyncObject.java b/lowlevel/SyncObject.java
@@ -3,20 +3,21 @@
 // We make no guarantees that this code is fit for any purpose.
 // Visit http://OnJava8.com for more book information.
 // Synchronizing on another object
+import onjava.Nap;
 
 class DualSynch {
   private Object syncObject = new Object();
   public synchronized void f() {
     for(int i = 0; i < 5; i++) {
       System.out.println("f()");
-      Thread.yield();
+      new Nap(10);
     }
   }
   public void g() {
     synchronized(syncObject) {
       for(int i = 0; i < 5; i++) {
         System.out.println("g()");
-        Thread.yield();
+        new Nap(10);
       }
     }
   }

Original file line number	Diff line number	Diff line change
`@@ -73,7 +73,7 @@ public void run() {`
`73`	`73`	`// Fill it up fast with random priorities:`
`74`	`74`	`for(int i = 0; i < 20; i++) {`
`75`	`75`	`queue.add(new PrioritizedTask(rand.nextInt(10)));`
`76`		`- Thread.yield();`
	`76`	`+ new Nap(10);`
`77`	`77`	`}`
`78`	`78`	`// Trickle in highest-priority jobs:`
`79`	`79`	`for(int i = 0; i < 10; i++) {`
Original file line number	Diff line number	Diff line change
`@@ -3,20 +3,21 @@`
`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`	`// Synchronizing on another object`
	`6`	`+import onjava.Nap;`
`6`	`7`
`7`	`8`	`class DualSynch {`
`8`	`9`	`private Object syncObject = new Object();`
`9`	`10`	`public synchronized void f() {`
`10`	`11`	`for(int i = 0; i < 5; i++) {`
`11`	`12`	`System.out.println("f()");`
`12`		`- Thread.yield();`
	`13`	`+ new Nap(10);`
`13`	`14`	`}`
`14`	`15`	`}`
`15`	`16`	`public void g() {`
`16`	`17`	`synchronized(syncObject) {`
`17`	`18`	`for(int i = 0; i < 5; i++) {`
`18`	`19`	`System.out.println("g()");`
`19`		`- Thread.yield();`
	`20`	`+ new Nap(10);`
`20`	`21`	`}`
`21`	`22`	`}`
`22`	`23`	`}`