ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/loops/LockLoops.java

Comparing jsr166/src/test/loops/LockLoops.java (file contents):
Revision 1.7 by jsr166, Tue Mar 15 19:47:05 2011 UTC vs.
Revision 1.16 by jsr166, Sat Dec 31 18:54:28 2016 UTC

#	Line 3 | Line 3
3		* Expert Group and released to the public domain, as explained at
4		* http://creativecommons.org/publicdomain/zero/1.0/
5		*/
6	+
7		/*
8	<	* A simple test program. Feel free to play.
8	>	* Simple benchmark comparing various locking techniques.
9		*/
10
11	<	import java.util.concurrent.*;
12	<	import java.util.concurrent.locks.*;
13	<	import java.util.*;
11	>	import java.util.concurrent.CyclicBarrier;
12	>	import java.util.concurrent.ExecutorService;
13	>	import java.util.concurrent.Executors;
14	>	import java.util.concurrent.Semaphore;
15	>	import java.util.concurrent.locks.Lock;
16	>	import java.util.concurrent.locks.ReentrantLock;
17	>	import java.util.concurrent.locks.ReentrantReadWriteLock;
18	>	import java.util.concurrent.locks.StampedLock;
19
20		public final class LockLoops {
21		static final ExecutorService pool = Executors.newCachedThreadPool();
#	Line 18 | Line 24 | public final class LockLoops {
24		static boolean doBuiltin = true;
25		static boolean doReadWrite = true;
26		static boolean doSemaphore = true;
27	<	static boolean doFair =  true;
27	>	static boolean doStampedLock = true;
28	>	static boolean doFair = true;
29
30		public static void main(String[] args) throws Exception {
31		int maxThreads = 100;
#	Line 90 | Line 97 | public final class LockLoops {
97		Thread.sleep(10);
98
99		if (print)
100	+	System.out.print("ReentrantReadLock    ");
101	+	new ReentrantReadLockLoop().test(v, nthreads, iters);
102	+	Thread.sleep(10);
103	+
104	+	if (print)
105		System.out.print("ReentrantReadWriteLock");
106		new ReentrantReadWriteLockLoop().test(v, nthreads, iters);
107		Thread.sleep(10);
96	–
108		}
109
110		if (doSemaphore) {
#	Line 106 | Line 117 | public final class LockLoops {
117		System.out.print("FairSemaphore         ");
118		new FairSemaphoreLoop().test(v, nthreads, iters);
119		Thread.sleep(10);
109	–
120		}
121
122		if (doFair) {
#	Line 126 | Line 136 | public final class LockLoops {
136		new FairReentrantReadWriteLockLoop().test(v, nthreads, iters);
137		Thread.sleep(10);
138		}
129	–
139		}
140
141	+	if (doStampedLock) {
142	+	if (print)
143	+	System.out.print("StampedLockWrite   ");
144	+	new StampedLockWriteLoop().test(v, nthreads, iters);
145	+	Thread.sleep(10);
146	+
147	+	if (print)
148	+	System.out.print("StampedLockRead    ");
149	+	new StampedLockReadLoop().test(v, nthreads, iters);
150	+	Thread.sleep(10);
151	+
152	+	if (print)
153	+	System.out.print("StampedLockOptRead");
154	+	new StampedLockOptimisticReadLoop().test(v, nthreads, iters);
155	+	Thread.sleep(10);
156	+
157	+	if (print)
158	+	System.out.print("StampedLockReadWrite");
159	+	new StampedLockReadWriteLoop().test(v, nthreads, iters);
160	+	Thread.sleep(10);
161	+	}
162		}
163
164		abstract static class LockLoop implements Runnable {
#	Line 264 | Line 294 | public final class LockLoops {
294		}
295		}
296
297	+	private static class ReentrantReadLockLoop extends LockLoop {
298	+	private final Lock lock = new ReentrantReadWriteLock().readLock();
299	+	final int loop(int n) {
300	+	int sum = 0;
301	+	while (n-- > 0) {
302	+	lock.lock();
303	+	try {
304	+	v = LoopHelpers.compute1(v);
305	+	}
306	+	finally {
307	+	lock.unlock();
308	+	}
309	+	sum += LoopHelpers.compute2(v);
310	+	}
311	+	return sum;
312	+	}
313	+	}
314	+
315		private static class ReentrantReadWriteLockLoop extends LockLoop {
316		private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
317		final int loop(int n) {
#	Line 330 | Line 378 | public final class LockLoops {
378		return sum;
379		}
380		}
381	+
382		private static class FairSemaphoreLoop extends LockLoop {
383		private final Semaphore sem = new Semaphore(1, true);
384		final int loop(int n) {
#	Line 379 | Line 428 | public final class LockLoops {
428		}
429		}
430
431	+	private static class StampedLockWriteLoop extends LockLoop {
432	+	private final StampedLock lock = new StampedLock();
433	+	final int loop(int n) {
434	+	int sum = 0;
435	+	while (n-- > 0) {
436	+	long stamp = lock.writeLock();
437	+	try {
438	+	v = LoopHelpers.compute1(v);
439	+	}
440	+	finally {
441	+	lock.unlockWrite(stamp);
442	+	}
443	+	sum += LoopHelpers.compute2(v);
444	+	}
445	+	return sum;
446	+	}
447	+	}
448	+
449	+	private static class StampedLockReadLoop extends LockLoop {
450	+	private final StampedLock lock = new StampedLock();
451	+	final int loop(int n) {
452	+	int sum = 0;
453	+	while (n-- > 0) {
454	+	long stamp = lock.readLock();
455	+	try {
456	+	v = LoopHelpers.compute1(v);
457	+	}
458	+	finally {
459	+	lock.unlockRead(stamp);
460	+	}
461	+	sum += LoopHelpers.compute2(v);
462	+	}
463	+	return sum;
464	+	}
465	+	}
466
467	+	private static class StampedLockOptimisticReadLoop extends LockLoop {
468	+	private final StampedLock lock = new StampedLock();
469	+	final int loop(int n) {
470	+	int sum = 0;
471	+	while (n-- > 0) {
472	+	long stamp;
473	+	do {
474	+	stamp = lock.tryOptimisticRead();
475	+	v = LoopHelpers.compute1(v);
476	+	} while (!lock.validate(stamp));
477	+	sum += LoopHelpers.compute2(v);
478	+	}
479	+	return sum;
480	+	}
481	+	}
482	+
483	+	private static class StampedLockReadWriteLoop extends LockLoop {
484	+	private final StampedLock lock = new StampedLock();
485	+	final int loop(int n) {
486	+	int sum = 0;
487	+	while (n-- > 0) {
488	+	int x;
489	+	long stamp = lock.readLock();
490	+	try {
491	+	x = LoopHelpers.compute1(v);
492	+	}
493	+	finally {
494	+	lock.unlockRead(stamp);
495	+	}
496	+	stamp = lock.writeLock();
497	+	try {
498	+	v = x;
499	+	} finally {
500	+	lock.unlockWrite(stamp);
501	+	}
502	+	sum += LoopHelpers.compute2(v);
503	+	}
504	+	return sum;
505	+	}
506	+	}
507		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines