Index: benchmark/creation/JavaThread.java
===================================================================
--- benchmark/creation/JavaThread.java	(revision 033ff3711d4010b2ccdeb4a02f5a7a01b1512ca6)
+++ benchmark/creation/JavaThread.java	(revision be53b87bb8b688d529b9f3ca8a4a7bfd47305629)
@@ -1,18 +1,56 @@
 public class JavaThread {
+	// Simplistic low-quality Marsaglia Shift-XOR pseudo-random number generator.
+	// Bijective   
+	// Cycle length for non-zero values is 4G-1.
+	// 0 is absorbing and should be avoided -- fixed point.
+	// The returned value is typically masked to produce a positive value.
+	static volatile int Ticket = 0 ; 
+
+	private static int nextRandom (int x) {
+		if (x == 0) { 
+			// reseed the PRNG
+			// Ticket is accessed infrequently and does not constitute a coherence hot-spot. 
+			// Note that we use a non-atomic racy increment -- the race is rare and benign. 
+			// If the race is a concern switch to an AtomicInteger.  
+			// In addition accesses to the RW volatile global "Ticket"  variable are not 
+			// (readily) predictable at compile-time so the JIT will not be able to elide 
+			// nextRandom() invocations.  
+			x = ++Ticket ; 
+			if (x == 0) x = 1 ; 
+		}
+		x ^= x << 6;
+		x ^= x >>> 21;
+		x ^= x << 7;
+		return x ;   
+	}
+	static int x = 2;
+
+	static private final int NoOfTimes = Integer.parseInt("10000") ;
+
 	public static class MyThread extends Thread {
 		@Override
 		public void run() {}
 	}
-
-	public static void main(String[] args) throws InterruptedException {
-		int NoOfTimes = 50000;
-		long start = System.nanoTime();
+	public static void helper() throws InterruptedException {
 		for(int i = 1; i <= NoOfTimes; i += 1) {
-			JavaThread.MyThread m = new JavaThread.MyThread();
-        		m.start();
+			MyThread m = new MyThread();
+			x = nextRandom( x );
+			m.start();
 			m.join();
 		}
+	}
+	public static void InnerMain() throws InterruptedException {
+		long start = System.nanoTime();
+		helper();
 		long end = System.nanoTime();
-		System.out.println( (end - start) / NoOfTimes);
+		System.out.println( (end - start) / NoOfTimes );
+	}
+	public static void main(String[] args) throws InterruptedException {
+		for (int n = Integer.parseInt("5"); --n >= 0 ; ) { 
+			InnerMain();
+			Thread.sleep(2000);     // 2 seconds
+			x = nextRandom(x);
+		}
+		if ( x == 0 ) System.out.println(x);
 	}
 }
Index: benchmark/ctxswitch/JavaThread.java
===================================================================
--- benchmark/ctxswitch/JavaThread.java	(revision 033ff3711d4010b2ccdeb4a02f5a7a01b1512ca6)
+++ benchmark/ctxswitch/JavaThread.java	(revision be53b87bb8b688d529b9f3ca8a4a7bfd47305629)
@@ -1,11 +1,49 @@
 public class JavaThread {
-	public static void main(String[] args) {
-		int NoOfTimes = 5000000;
-		long start = System.nanoTime();
+	// Simplistic low-quality Marsaglia Shift-XOR pseudo-random number generator.
+	// Bijective   
+	// Cycle length for non-zero values is 4G-1.
+	// 0 is absorbing and should be avoided -- fixed point.
+	// The returned value is typically masked to produce a positive value.
+	static volatile int Ticket = 0 ; 
+
+	private static int nextRandom (int x) {
+		if (x == 0) { 
+			// reseed the PRNG
+			// Ticket is accessed infrequently and does not constitute a coherence hot-spot. 
+			// Note that we use a non-atomic racy increment -- the race is rare and benign. 
+			// If the race is a concern switch to an AtomicInteger.  
+			// In addition accesses to the RW volatile global "Ticket"  variable are not 
+			// (readily) predictable at compile-time so the JIT will not be able to elide 
+			// nextRandom() invocations.  
+			x = ++Ticket ; 
+			if (x == 0) x = 1 ; 
+		}
+		x ^= x << 6;
+		x ^= x >>> 21;
+		x ^= x << 7;
+		return x ;   
+	}
+	static int x = 2;
+
+	static private final int NoOfTimes = Integer.parseInt("1000000") ;
+
+	public static void helper() {
 		for(int i = 1; i <= NoOfTimes; i += 1) {
 			Thread.yield();
 		}
+	}
+	public static void InnerMain() {
+		long start = System.nanoTime();
+		helper();
 		long end = System.nanoTime();
-		System.out.println( (end - start) / NoOfTimes);
+		System.out.println( (end - start) / NoOfTimes );
+	}
+	public static void main(String[] args) throws InterruptedException {
+		for (int n = Integer.parseInt("5"); --n >= 0 ; ) { 
+			InnerMain();
+			Thread.sleep(2000);     // 2 seconds
+			x = nextRandom(x);
+		}
+		if ( x == 0 ) System.out.println(x);
 	}
 }
Index: benchmark/mutex/JavaThread.java
===================================================================
--- benchmark/mutex/JavaThread.java	(revision 033ff3711d4010b2ccdeb4a02f5a7a01b1512ca6)
+++ benchmark/mutex/JavaThread.java	(revision be53b87bb8b688d529b9f3ca8a4a7bfd47305629)
@@ -1,14 +1,56 @@
 public class JavaThread {
-	public synchronized void noop() {}
+	// Simplistic low-quality Marsaglia Shift-XOR pseudo-random number generator.
+	// Bijective   
+	// Cycle length for non-zero values is 4G-1.
+	// 0 is absorbing and should be avoided -- fixed point.
+	// The returned value is typically masked to produce a positive value.
+	static volatile int Ticket = 0 ; 
 
-	public static void main(String[] args) {
-		int NoOfTimes = 5000000;
+	private static int nextRandom (int x) {
+		if (x == 0) { 
+			// reseed the PRNG
+			// Ticket is accessed infrequently and does not constitute a coherence hot-spot. 
+			// Note that we use a non-atomic racy increment -- the race is rare and benign. 
+			// If the race is a concern switch to an AtomicInteger.  
+			// In addition accesses to the RW volatile global "Ticket"  variable are not 
+			// (readily) predictable at compile-time so the JIT will not be able to elide 
+			// nextRandom() invocations.  
+			x = ++Ticket ; 
+			if (x == 0) x = 1 ; 
+		}
+		x ^= x << 6;
+		x ^= x >>> 21;
+		x ^= x << 7;
+		return x ;   
+	}
+	static int x = 2;
+
+	static private final int NoOfTimes = Integer.parseInt("100000000") ;
+
+	public synchronized void noop() {
+		x = nextRandom( x );
+	}
+	public static void helper() throws InterruptedException {
 		JavaThread j = new JavaThread();
-		long start = System.nanoTime();
+		// Inhibit biased locking ...
+		x = (j.hashCode() ^ System.identityHashCode(j)) | 1 ;     
 		for(int i = 1; i <= NoOfTimes; i += 1) {
+			x = nextRandom(x);
 			j.noop();
 		}
+	}
+	public static void InnerMain() throws InterruptedException {
+		long start = System.nanoTime();
+		helper();
 		long end = System.nanoTime();
-		System.out.println( (end - start) / NoOfTimes);
+		System.out.println( (end - start) / NoOfTimes );
+	}
+	public static void main(String[] args) throws InterruptedException {
+		for (int n = Integer.parseInt("5"); --n >= 0 ; ) { 
+			InnerMain();
+			Thread.sleep(2000);     // 2 seconds
+			x = nextRandom(x);
+		}
+		if ( x == 0 ) System.out.println(x);
 	}
 }
Index: benchmark/schedint/JavaThread.java
===================================================================
--- benchmark/schedint/JavaThread.java	(revision 033ff3711d4010b2ccdeb4a02f5a7a01b1512ca6)
+++ benchmark/schedint/JavaThread.java	(revision be53b87bb8b688d529b9f3ca8a4a7bfd47305629)
@@ -1,4 +1,5 @@
 class Monitor {
 	public static volatile Boolean go = false;
+	public static volatile Boolean next = false;
 }
 
@@ -13,6 +14,8 @@
 		while( Monitor.go ) {
 			synchronized(this.m) {
+				Monitor.next = false;
 				this.m.notify();
 			}
+			while( ! Monitor.next && Monitor.go );	// spin until woken
 		}
 	}
@@ -20,6 +23,39 @@
 
 public class JavaThread {
-	public static void main(String[] args) throws InterruptedException {
-		int NoOfTimes = 50000;
+	// Simplistic low-quality Marsaglia Shift-XOR pseudo-random number generator.
+	// Bijective   
+	// Cycle length for non-zero values is 4G-1.
+	// 0 is absorbing and should be avoided -- fixed point.
+	// The returned value is typically masked to produce a positive value.
+	static volatile int Ticket = 0 ; 
+
+	private static int nextRandom (int x) {
+		if (x == 0) { 
+			// reseed the PRNG
+			// Ticket is accessed infrequently and does not constitute a coherence hot-spot. 
+			// Note that we use a non-atomic racy increment -- the race is rare and benign. 
+			// If the race is a concern switch to an AtomicInteger.  
+			// In addition accesses to the RW volatile global "Ticket"  variable are not 
+			// (readily) predictable at compile-time so the JIT will not be able to elide 
+			// nextRandom() invocations.  
+			x = ++Ticket ; 
+			if (x == 0) x = 1 ; 
+		}
+		x ^= x << 6;
+		x ^= x >>> 21;
+		x ^= x << 7;
+		return x ;   
+	}
+	static int x = 2;
+
+	static private final int NoOfTimes = Integer.parseInt("1000000") ;
+
+	public static void helper( Monitor m ) throws InterruptedException {
+		for(int i = 1; i <= NoOfTimes; i += 1) {
+			m.wait();		// relase monitor lock
+			m.next = true;
+		}
+	}
+	public static void InnerMain() throws InterruptedException {
 		Monitor m = new Monitor();
 		long start, end;
@@ -31,7 +67,5 @@
 			}
 			start = System.nanoTime();
-			for(int i = 1; i <= NoOfTimes; i += 1) {
-				m.wait();
-			}
+			helper( m );
 			end = System.nanoTime();
 		}
@@ -40,3 +74,11 @@
 		System.out.println( (end - start) / NoOfTimes);
 	}
+	public static void main(String[] args) throws InterruptedException {
+		for (int n = Integer.parseInt("5"); --n >= 0 ; ) { 
+			InnerMain();
+			Thread.sleep(2000);     // 2 seconds
+			x = nextRandom(x);
+		}
+		if ( x == 0 ) System.out.println(x);
+	}
 }