test/loops/LockLoops.java

/*
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
 * http://creativecommons.org/publicdomain/zero/1.0/
 */
/*
 * A simple test program. Feel free to play.
 */

import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.locks.*;

public final class LockLoops {
    static final ExecutorService pool = Executors.newCachedThreadPool();
    static final LoopHelpers.SimpleRandom rng = new LoopHelpers.SimpleRandom();
    static boolean print = false;
    static boolean doBuiltin = true;
    static boolean doReadWrite = true;
    static boolean doSemaphore = true;
    static boolean doStampedLock = true;
    static boolean doFair = true;

    public static void main(String[] args) throws Exception {
        int maxThreads = 100;
        int iters = 1000000;
        int replications = 1;

        if (args.length > 0)
            maxThreads = Integer.parseInt(args[0]);

        if (args.length > 1)
            iters = Integer.parseInt(args[1]);

        if (args.length > 2)
            replications = Integer.parseInt(args[2]);

        rng.setSeed(3122688L);

        print = false;
        System.out.println("Warmup...");
        oneTest(3, 10000);
        Thread.sleep(1000);
        oneTest(2, 10000);
        Thread.sleep(100);
        oneTest(1, 100000);
        Thread.sleep(100);
        oneTest(1, 100000);
        Thread.sleep(1000);
        print = true;

        for (int i = 1; i <= maxThreads; ++i) {
            for (int j = 0; j < replications; ++j) {
                System.out.println("Threads:" + i);
                oneTest(i, iters / i);
                Thread.sleep(100);
            }
        }
        pool.shutdown();
    }

    static void oneTest(int nthreads, int iters) throws Exception {
        int v = rng.next();

        if (print)
            System.out.print("No shared vars        ");
        new NoLockLoop().test(v, nthreads, iters * 10);
        Thread.sleep(10);

        if (print)
            System.out.print("No Lock + volatile    ");
        new NoLockVolatileLoop().test(v, nthreads, iters);
        Thread.sleep(10);

        if (doBuiltin) {
            if (print)
                System.out.print("builtin lock          ");
            new BuiltinLockLoop().test(v, nthreads, iters);
            Thread.sleep(10);
        }

        if (print)
            System.out.print("ReentrantLock         ");
        new ReentrantLockLoop().test(v, nthreads, iters);
        Thread.sleep(10);

        if (doReadWrite) {
            if (print)
                System.out.print("ReentrantWriteLock    ");
            new ReentrantWriteLockLoop().test(v, nthreads, iters);
            Thread.sleep(10);

            if (print)
                System.out.print("ReentrantReadWriteLock");
            new ReentrantReadWriteLockLoop().test(v, nthreads, iters);
            Thread.sleep(10);
        }

        if (doSemaphore) {
            if (print)
                System.out.print("Semaphore             ");
            new SemaphoreLoop().test(v, nthreads, iters);
            Thread.sleep(10);

            if (print)
                System.out.print("FairSemaphore         ");
            new FairSemaphoreLoop().test(v, nthreads, iters);
            Thread.sleep(10);
        }

        if (doFair) {
            if (print)
                System.out.print("FairReentrantLock     ");
            new FairReentrantLockLoop().test(v, nthreads, iters);
            Thread.sleep(10);

            if (doReadWrite) {
                if (print)
                    System.out.print("FairRWriteLock         ");
                new FairReentrantWriteLockLoop().test(v, nthreads, iters);
                Thread.sleep(10);

                if (print)
                    System.out.print("FairRReadWriteLock     ");
                new FairReentrantReadWriteLockLoop().test(v, nthreads, iters);
                Thread.sleep(10);
            }
        }

        if (doStampedLock) {
            if (print)
                System.out.print("StampedLockWrite   ");
            new StampedLockWriteLoop().test(v, nthreads, iters);
            Thread.sleep(10);

            if (print)
                System.out.print("StampedLockRead    ");
            new StampedLockReadLoop().test(v, nthreads, iters);
            Thread.sleep(10);

            if (print)
                System.out.print("StampedLockOptRead");
            new StampedLockOptimisticReadLoop().test(v, nthreads, iters);
            Thread.sleep(10);

            if (print)
                System.out.print("StampedLockReadWrite");
            new StampedLockReadWriteLoop().test(v, nthreads, iters);
            Thread.sleep(10);
        }
    }

    abstract static class LockLoop implements Runnable {
        int v;
        int iters;
        volatile int result;
        final LoopHelpers.BarrierTimer timer = new LoopHelpers.BarrierTimer();
        CyclicBarrier barrier;

        final void test(int initialValue, int nthreads, int iters) throws Exception {
            v = initialValue;
            this.iters = iters;
            barrier = new CyclicBarrier(nthreads+1, timer);
            for (int i = 0; i < nthreads; ++i)
                pool.execute(this);
            barrier.await();
            barrier.await();
            long time = timer.getTime();
            if (print) {
                long tpi = time / (iters * nthreads);
                System.out.print("\t" + LoopHelpers.rightJustify(tpi) + " ns per update");
                //                double secs = (double) time / 1000000000.0;
                //                System.out.print("\t " + secs + "s run time");
                System.out.println();
            }

            if (result == 0) // avoid overoptimization
                System.out.println("useless result: " + result);
        }
        abstract int loop(int n);
        public final void run() {
            try {
                barrier.await();
                result += loop(iters);
                barrier.await();
            }
            catch (Exception ie) {
                return;
            }
        }

    }

    private static class BuiltinLockLoop extends LockLoop {
        final int loop(int n) {
            int sum = 0;
            while (n-- > 0) {
                synchronized (this) {
                    v = LoopHelpers.compute1(v);
                }
                sum += LoopHelpers.compute2(v);
            }
            return sum;
        }
    }

    private static class NoLockLoop extends LockLoop {
        final int loop(int n) {
            int sum = 0;
            int y = v;
            while (n-- > 0) {
                y = LoopHelpers.compute1(y);
                sum += LoopHelpers.compute2(y);
            }
            return sum;
        }
    }

    private static class NoLockVolatileLoop extends LockLoop {
        private volatile int vv;
        final int loop(int n) {
            int sum = 0;
            while (n-- > 0) {
                int y = LoopHelpers.compute1(vv);
                vv = y;
                sum += LoopHelpers.compute2(y);
            }
            return sum;
        }
    }

    private static class ReentrantLockLoop extends LockLoop {
        private final ReentrantLock lock = new ReentrantLock();
        final int loop(int n) {
            int sum = 0;
            while (n-- > 0) {
                lock.lock();
                try {
                    v = LoopHelpers.compute1(v);
                }
                finally {
                    lock.unlock();
                }
                sum += LoopHelpers.compute2(v);
            }
            return sum;
        }
    }

    private static class FairReentrantLockLoop extends LockLoop {
        private final ReentrantLock lock = new ReentrantLock(true);
        final int loop(int n) {
            int sum = 0;
            while (n-- > 0) {
                lock.lock();
                try {
                    v = LoopHelpers.compute1(v);
                }
                finally {
                    lock.unlock();
                }
                sum += LoopHelpers.compute2(v);
            }
            return sum;
        }
    }

    private static class ReentrantWriteLockLoop extends LockLoop {
        private final Lock lock = new ReentrantReadWriteLock().writeLock();
        final int loop(int n) {
            int sum = 0;
            while (n-- > 0) {
                lock.lock();
                try {
                    v = LoopHelpers.compute1(v);
                }
                finally {
                    lock.unlock();
                }
                sum += LoopHelpers.compute2(v);
            }
            return sum;
        }
    }

    private static class ReentrantReadWriteLockLoop extends LockLoop {
        private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
        final int loop(int n) {
            int sum = 0;
            while (n-- > 0) {
                int x;
                lock.readLock().lock();
                try {
                    x = LoopHelpers.compute1(v);
                }
                finally {
                    lock.readLock().unlock();
                }
                lock.writeLock().lock();
                try {
                    v = x;
                }
                finally {
                    lock.writeLock().unlock();
                }
                sum += LoopHelpers.compute2(v);
            }
            return sum;
        }
    }

    private static class FairReentrantWriteLockLoop extends LockLoop {
        final Lock lock = new ReentrantReadWriteLock(true).writeLock();
        final int loop(int n) {
            int sum = 0;
            while (n-- > 0) {
                lock.lock();
                try {
                    v = LoopHelpers.compute1(v);
                }
                finally {
                    lock.unlock();
                }
                sum += LoopHelpers.compute2(v);
            }
            return sum;
        }
    }

    private static class SemaphoreLoop extends LockLoop {
        private final Semaphore sem = new Semaphore(1, false);
        final int loop(int n) {
            int sum = 0;
            try {
                while (n-- > 0) {
                    sem.acquire();
                    try {
                        v = LoopHelpers.compute1(v);
                    }
                    finally {
                        sem.release();
                    }
                    sum += LoopHelpers.compute2(v);
                }
            }
            catch (InterruptedException ie) {
                return sum;
            }
            return sum;
        }
    }

    private static class FairSemaphoreLoop extends LockLoop {
        private final Semaphore sem = new Semaphore(1, true);
        final int loop(int n) {
            int sum = 0;
            try {
                while (n-- > 0) {
                    sem.acquire();
                    try {
                        v = LoopHelpers.compute1(v);
                    }
                    finally {
                        sem.release();
                    }
                    sum += LoopHelpers.compute2(v);
                }
            }
            catch (InterruptedException ie) {
                return sum;
            }
            return sum;
        }
    }

    private static class FairReentrantReadWriteLockLoop extends LockLoop {
        private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
        final int loop(int n) {
            int sum = 0;
            while (n-- > 0) {
                int x;
                lock.readLock().lock();
                try {
                    x = LoopHelpers.compute1(v);
                }
                finally {
                    lock.readLock().unlock();
                }
                lock.writeLock().lock();
                try {
                    v = x;
                }
                finally {
                    lock.writeLock().unlock();
                }
                sum += LoopHelpers.compute2(v);
            }
            return sum;
        }
    }

    private static class StampedLockWriteLoop extends LockLoop {
        private final StampedLock lock = new StampedLock();
        final int loop(int n) {
            int sum = 0;
            while (n-- > 0) {
                long stamp = lock.writeLock();
                try {
                    v = LoopHelpers.compute1(v);
                }
                finally {
                    lock.unlockWrite(stamp);
                }
                sum += LoopHelpers.compute2(v);
            }
            return sum;
        }
    }

    private static class StampedLockReadLoop extends LockLoop {
        private final StampedLock lock = new StampedLock();
        final int loop(int n) {
            int sum = 0;
            while (n-- > 0) {
                long stamp = lock.readLock();
                try {
                    v = LoopHelpers.compute1(v);
                }
                finally {
                    lock.unlockRead(stamp);
                }
                sum += LoopHelpers.compute2(v);
            }
            return sum;
        }
    }

    private static class StampedLockOptimisticReadLoop extends LockLoop {
        private final StampedLock lock = new StampedLock();
        final int loop(int n) {
            int sum = 0;
            while (n-- > 0) {
                long stamp;
                do {
                    stamp = lock.tryOptimisticRead();
                    v = LoopHelpers.compute1(v);
                } while (!lock.validate(stamp));
                sum += LoopHelpers.compute2(v);
            }
            return sum;
        }
    }

    private static class StampedLockReadWriteLoop extends LockLoop {
        private final StampedLock lock = new StampedLock();
        final int loop(int n) {
            int sum = 0;
            while (n-- > 0) {
                int x;
                long stamp = lock.readLock();
                try {
                    x = LoopHelpers.compute1(v);
                }
                finally {
                    lock.unlockRead(stamp);
                }
                stamp = lock.writeLock();
                try {
                    v = x;
                } finally {
                    lock.unlockWrite(stamp);
                }
                sum += LoopHelpers.compute2(v);
            }
            return sum;
        }
    }
}
Revision:	1.14
Committed:	Wed Jun 8 20:42:12 2016 UTC (7 years, 11 months ago) by jsr166
Branch:	MAIN
Changes since 1.13:	+22 -1 lines
Log Message:	add StampedLockOptimisticReadLoop
#	User	Rev	Content
1	dl	1.1	/*
2	dl	1.2	* Written by Doug Lea with assistance from members of JCP JSR-166
3			* Expert Group and released to the public domain, as explained at
4	jsr166	1.7	* http://creativecommons.org/publicdomain/zero/1.0/
5	dl	1.2	*/
6			/*
7	dl	1.1	* A simple test program. Feel free to play.
8			*/
9
10	jsr166	1.9	import java.util.*;
11	dl	1.1	import java.util.concurrent.*;
12			import java.util.concurrent.locks.*;
13
14			public final class LockLoops {
15			static final ExecutorService pool = Executors.newCachedThreadPool();
16			static final LoopHelpers.SimpleRandom rng = new LoopHelpers.SimpleRandom();
17			static boolean print = false;
18			static boolean doBuiltin = true;
19			static boolean doReadWrite = true;
20			static boolean doSemaphore = true;
21	jsr166	1.12	static boolean doStampedLock = true;
22	jsr166	1.8	static boolean doFair = true;
23	dl	1.1
24			public static void main(String[] args) throws Exception {
25			int maxThreads = 100;
26			int iters = 1000000;
27			int replications = 1;
28
29	jsr166	1.3	if (args.length > 0)
30	dl	1.1	maxThreads = Integer.parseInt(args[0]);
31
32	jsr166	1.3	if (args.length > 1)
33	dl	1.1	iters = Integer.parseInt(args[1]);
34
35	jsr166	1.3	if (args.length > 2)
36	dl	1.1	replications = Integer.parseInt(args[2]);
37
38			rng.setSeed(3122688L);
39
40			print = false;
41			System.out.println("Warmup...");
42			oneTest(3, 10000);
43			Thread.sleep(1000);
44			oneTest(2, 10000);
45			Thread.sleep(100);
46			oneTest(1, 100000);
47			Thread.sleep(100);
48			oneTest(1, 100000);
49			Thread.sleep(1000);
50			print = true;
51
52			for (int i = 1; i <= maxThreads; ++i) {
53			for (int j = 0; j < replications; ++j) {
54			System.out.println("Threads:" + i);
55			oneTest(i, iters / i);
56			Thread.sleep(100);
57			}
58			}
59			pool.shutdown();
60			}
61
62			static void oneTest(int nthreads, int iters) throws Exception {
63			int v = rng.next();
64
65			if (print)
66			System.out.print("No shared vars ");
67			new NoLockLoop().test(v, nthreads, iters * 10);
68			Thread.sleep(10);
69
70			if (print)
71			System.out.print("No Lock + volatile ");
72			new NoLockVolatileLoop().test(v, nthreads, iters);
73			Thread.sleep(10);
74
75			if (doBuiltin) {
76			if (print)
77			System.out.print("builtin lock ");
78			new BuiltinLockLoop().test(v, nthreads, iters);
79			Thread.sleep(10);
80			}
81
82			if (print)
83			System.out.print("ReentrantLock ");
84			new ReentrantLockLoop().test(v, nthreads, iters);
85			Thread.sleep(10);
86
87			if (doReadWrite) {
88			if (print)
89			System.out.print("ReentrantWriteLock ");
90			new ReentrantWriteLockLoop().test(v, nthreads, iters);
91			Thread.sleep(10);
92
93			if (print)
94			System.out.print("ReentrantReadWriteLock");
95			new ReentrantReadWriteLockLoop().test(v, nthreads, iters);
96			Thread.sleep(10);
97			}
98
99			if (doSemaphore) {
100			if (print)
101			System.out.print("Semaphore ");
102			new SemaphoreLoop().test(v, nthreads, iters);
103			Thread.sleep(10);
104
105			if (print)
106			System.out.print("FairSemaphore ");
107			new FairSemaphoreLoop().test(v, nthreads, iters);
108			Thread.sleep(10);
109			}
110
111			if (doFair) {
112			if (print)
113			System.out.print("FairReentrantLock ");
114			new FairReentrantLockLoop().test(v, nthreads, iters);
115			Thread.sleep(10);
116
117			if (doReadWrite) {
118			if (print)
119			System.out.print("FairRWriteLock ");
120			new FairReentrantWriteLockLoop().test(v, nthreads, iters);
121			Thread.sleep(10);
122
123			if (print)
124			System.out.print("FairRReadWriteLock ");
125			new FairReentrantReadWriteLockLoop().test(v, nthreads, iters);
126			Thread.sleep(10);
127			}
128			}
129	jsr166	1.12
130			if (doStampedLock) {
131			if (print)
132			System.out.print("StampedLockWrite ");
133			new StampedLockWriteLoop().test(v, nthreads, iters);
134			Thread.sleep(10);
135
136			if (print)
137			System.out.print("StampedLockRead ");
138			new StampedLockReadLoop().test(v, nthreads, iters);
139			Thread.sleep(10);
140	jsr166	1.13
141			if (print)
142	jsr166	1.14	System.out.print("StampedLockOptRead");
143			new StampedLockOptimisticReadLoop().test(v, nthreads, iters);
144			Thread.sleep(10);
145
146			if (print)
147	jsr166	1.13	System.out.print("StampedLockReadWrite");
148	jsr166	1.14	new StampedLockReadWriteLoop().test(v, nthreads, iters);
149	jsr166	1.13	Thread.sleep(10);
150	jsr166	1.12	}
151	dl	1.1	}
152
153	jsr166	1.6	abstract static class LockLoop implements Runnable {
154	dl	1.1	int v;
155			int iters;
156			volatile int result;
157			final LoopHelpers.BarrierTimer timer = new LoopHelpers.BarrierTimer();
158			CyclicBarrier barrier;
159
160			final void test(int initialValue, int nthreads, int iters) throws Exception {
161			v = initialValue;
162			this.iters = iters;
163			barrier = new CyclicBarrier(nthreads+1, timer);
164	jsr166	1.3	for (int i = 0; i < nthreads; ++i)
165	dl	1.1	pool.execute(this);
166			barrier.await();
167			barrier.await();
168			long time = timer.getTime();
169			if (print) {
170			long tpi = time / (iters * nthreads);
171			System.out.print("\t" + LoopHelpers.rightJustify(tpi) + " ns per update");
172	jsr166	1.4	// double secs = (double) time / 1000000000.0;
173	dl	1.1	// System.out.print("\t " + secs + "s run time");
174			System.out.println();
175			}
176
177			if (result == 0) // avoid overoptimization
178			System.out.println("useless result: " + result);
179			}
180			abstract int loop(int n);
181			public final void run() {
182			try {
183	jsr166	1.3	barrier.await();
184	dl	1.1	result += loop(iters);
185			barrier.await();
186			}
187	jsr166	1.3	catch (Exception ie) {
188			return;
189	dl	1.1	}
190			}
191
192			}
193
194			private static class BuiltinLockLoop extends LockLoop {
195			final int loop(int n) {
196			int sum = 0;
197			while (n-- > 0) {
198	jsr166	1.5	synchronized (this) {
199	dl	1.1	v = LoopHelpers.compute1(v);
200			}
201			sum += LoopHelpers.compute2(v);
202			}
203			return sum;
204			}
205			}
206
207			private static class NoLockLoop extends LockLoop {
208			final int loop(int n) {
209			int sum = 0;
210			int y = v;
211			while (n-- > 0) {
212			y = LoopHelpers.compute1(y);
213			sum += LoopHelpers.compute2(y);
214			}
215			return sum;
216			}
217			}
218
219			private static class NoLockVolatileLoop extends LockLoop {
220	jsr166	1.6	private volatile int vv;
221	dl	1.1	final int loop(int n) {
222			int sum = 0;
223			while (n-- > 0) {
224			int y = LoopHelpers.compute1(vv);
225			vv = y;
226			sum += LoopHelpers.compute2(y);
227			}
228			return sum;
229			}
230			}
231
232			private static class ReentrantLockLoop extends LockLoop {
233	jsr166	1.6	private final ReentrantLock lock = new ReentrantLock();
234	dl	1.1	final int loop(int n) {
235			int sum = 0;
236			while (n-- > 0) {
237			lock.lock();
238			try {
239			v = LoopHelpers.compute1(v);
240			}
241			finally {
242			lock.unlock();
243			}
244			sum += LoopHelpers.compute2(v);
245			}
246			return sum;
247			}
248			}
249
250			private static class FairReentrantLockLoop extends LockLoop {
251	jsr166	1.6	private final ReentrantLock lock = new ReentrantLock(true);
252	dl	1.1	final int loop(int n) {
253			int sum = 0;
254			while (n-- > 0) {
255			lock.lock();
256			try {
257			v = LoopHelpers.compute1(v);
258			}
259			finally {
260			lock.unlock();
261			}
262			sum += LoopHelpers.compute2(v);
263			}
264			return sum;
265			}
266			}
267
268			private static class ReentrantWriteLockLoop extends LockLoop {
269	jsr166	1.6	private final Lock lock = new ReentrantReadWriteLock().writeLock();
270	dl	1.1	final int loop(int n) {
271			int sum = 0;
272			while (n-- > 0) {
273			lock.lock();
274			try {
275			v = LoopHelpers.compute1(v);
276			}
277			finally {
278			lock.unlock();
279			}
280			sum += LoopHelpers.compute2(v);
281			}
282			return sum;
283			}
284			}
285
286			private static class ReentrantReadWriteLockLoop extends LockLoop {
287	jsr166	1.6	private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
288	dl	1.1	final int loop(int n) {
289			int sum = 0;
290			while (n-- > 0) {
291			int x;
292			lock.readLock().lock();
293			try {
294			x = LoopHelpers.compute1(v);
295			}
296			finally {
297			lock.readLock().unlock();
298			}
299			lock.writeLock().lock();
300			try {
301			v = x;
302			}
303			finally {
304			lock.writeLock().unlock();
305			}
306			sum += LoopHelpers.compute2(v);
307			}
308			return sum;
309			}
310			}
311
312			private static class FairReentrantWriteLockLoop extends LockLoop {
313			final Lock lock = new ReentrantReadWriteLock(true).writeLock();
314			final int loop(int n) {
315			int sum = 0;
316			while (n-- > 0) {
317			lock.lock();
318			try {
319			v = LoopHelpers.compute1(v);
320			}
321			finally {
322			lock.unlock();
323			}
324			sum += LoopHelpers.compute2(v);
325			}
326			return sum;
327			}
328			}
329
330			private static class SemaphoreLoop extends LockLoop {
331	jsr166	1.6	private final Semaphore sem = new Semaphore(1, false);
332	dl	1.1	final int loop(int n) {
333			int sum = 0;
334			try {
335			while (n-- > 0) {
336			sem.acquire();
337			try {
338			v = LoopHelpers.compute1(v);
339			}
340			finally {
341			sem.release();
342			}
343			sum += LoopHelpers.compute2(v);
344			}
345			}
346			catch (InterruptedException ie) {
347			return sum;
348			}
349			return sum;
350			}
351			}
352	jsr166	1.12
353	dl	1.1	private static class FairSemaphoreLoop extends LockLoop {
354	jsr166	1.6	private final Semaphore sem = new Semaphore(1, true);
355	dl	1.1	final int loop(int n) {
356			int sum = 0;
357			try {
358			while (n-- > 0) {
359			sem.acquire();
360			try {
361			v = LoopHelpers.compute1(v);
362			}
363			finally {
364			sem.release();
365			}
366			sum += LoopHelpers.compute2(v);
367			}
368			}
369			catch (InterruptedException ie) {
370			return sum;
371			}
372			return sum;
373			}
374			}
375
376			private static class FairReentrantReadWriteLockLoop extends LockLoop {
377	jsr166	1.6	private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
378	dl	1.1	final int loop(int n) {
379			int sum = 0;
380			while (n-- > 0) {
381			int x;
382			lock.readLock().lock();
383			try {
384			x = LoopHelpers.compute1(v);
385			}
386			finally {
387			lock.readLock().unlock();
388			}
389			lock.writeLock().lock();
390			try {
391			v = x;
392			}
393			finally {
394			lock.writeLock().unlock();
395			}
396			sum += LoopHelpers.compute2(v);
397			}
398			return sum;
399			}
400			}
401	jsr166	1.12
402			private static class StampedLockWriteLoop extends LockLoop {
403			private final StampedLock lock = new StampedLock();
404			final int loop(int n) {
405			int sum = 0;
406			while (n-- > 0) {
407			long stamp = lock.writeLock();
408			try {
409			v = LoopHelpers.compute1(v);
410			}
411			finally {
412			lock.unlockWrite(stamp);
413			}
414			sum += LoopHelpers.compute2(v);
415			}
416			return sum;
417			}
418			}
419
420			private static class StampedLockReadLoop extends LockLoop {
421			private final StampedLock lock = new StampedLock();
422			final int loop(int n) {
423			int sum = 0;
424			while (n-- > 0) {
425			long stamp = lock.readLock();
426			try {
427			v = LoopHelpers.compute1(v);
428			}
429			finally {
430			lock.unlockRead(stamp);
431			}
432			sum += LoopHelpers.compute2(v);
433			}
434			return sum;
435			}
436			}
437	jsr166	1.13
438	jsr166	1.14	private static class StampedLockOptimisticReadLoop extends LockLoop {
439			private final StampedLock lock = new StampedLock();
440			final int loop(int n) {
441			int sum = 0;
442			while (n-- > 0) {
443			long stamp;
444			do {
445			stamp = lock.tryOptimisticRead();
446			v = LoopHelpers.compute1(v);
447			} while (!lock.validate(stamp));
448			sum += LoopHelpers.compute2(v);
449			}
450			return sum;
451			}
452			}
453
454	jsr166	1.13	private static class StampedLockReadWriteLoop extends LockLoop {
455			private final StampedLock lock = new StampedLock();
456			final int loop(int n) {
457			int sum = 0;
458			while (n-- > 0) {
459			int x;
460			long stamp = lock.readLock();
461			try {
462			x = LoopHelpers.compute1(v);
463			}
464			finally {
465			lock.unlockRead(stamp);
466			}
467			stamp = lock.writeLock();
468			try {
469			v = x;
470			} finally {
471			lock.unlockWrite(stamp);
472			}
473			sum += LoopHelpers.compute2(v);
474			}
475			return sum;
476			}
477			}
478	dl	1.1	}