ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/loops/UncheckedLockLoops.java
(Generate patch)

Comparing jsr166/src/test/loops/UncheckedLockLoops.java (file contents):
Revision 1.2 by dl, Mon May 9 19:33:30 2005 UTC vs.
Revision 1.11 by jsr166, Thu Jan 15 18:34:19 2015 UTC

# Line 1 | Line 1
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 < * http://creativecommons.org/licenses/publicdomain
4 > * http://creativecommons.org/publicdomain/zero/1.0/
5   */
6   /*
7   * @test
8   * @summary basic safety and liveness of ReentrantLocks, and other locks based on them
9   */
10  
11 + import java.util.*;
12   import java.util.concurrent.*;
13   import java.util.concurrent.locks.*;
13 – import java.util.*;
14  
15   public final class UncheckedLockLoops {
16      static final LoopHelpers.SimpleRandom rng = new LoopHelpers.SimpleRandom();
# Line 21 | Line 21 | public final class UncheckedLockLoops {
21          int maxThreads = 100;
22          int iters = 10000000;
23  
24 <        if (args.length > 0)
24 >        if (args.length > 0)
25              maxThreads = Integer.parseInt(args[0]);
26  
27          rng.setSeed(3122688L);
# Line 53 | Line 53 | public final class UncheckedLockLoops {
53      }
54  
55      static void oneTest(int nthreads, int iters) throws Exception {
56 <        int fairIters = (nthreads <= 1)? iters : iters/20;
56 >        int fairIters = (nthreads <= 1) ? iters : iters/20;
57          int v = rng.next();
58  
59          if (print)
60              System.out.print("NoLock (1 thread)     ");
61          new NoLockLoop().test(v, 1, iters * nthreads);
62          Thread.sleep(10);
63 <
63 >
64          if (print)
65              System.out.print("ReentrantLock         ");
66          new ReentrantLockLoop().test(v, nthreads, iters);
# Line 93 | Line 93 | public final class UncheckedLockLoops {
93              System.out.print("Semaphore             ");
94          new SemaphoreLoop().test(v, nthreads, iters);
95          Thread.sleep(10);
96 <        
96 >
97          if (print)
98              System.out.print("FairSemaphore         ");
99          new FairSemaphoreLoop().test(v, nthreads, fairIters);
# Line 108 | Line 108 | public final class UncheckedLockLoops {
108              System.out.print("FairRWriteLock         ");
109          new FairReentrantWriteLockLoop().test(v, nthreads, fairIters);
110          Thread.sleep(10);
111 <        
111 >
112          if (print)
113              System.out.print("ReentrantReadWriteLock");
114          new ReentrantReadWriteLockLoop().test(v, nthreads, iters);
115          Thread.sleep(10);
116 <        
116 >
117          if (print)
118              System.out.print("FairRReadWriteLock     ");
119          new FairReentrantReadWriteLockLoop().test(v, nthreads, fairIters);
# Line 121 | Line 121 | public final class UncheckedLockLoops {
121  
122      }
123  
124 <    static abstract class LockLoop implements Runnable {
124 >    abstract static class LockLoop implements Runnable {
125          int value;
126          int checkValue;
127          int iters;
# Line 138 | Line 138 | public final class UncheckedLockLoops {
138  
139          final int getValue() {
140              int v = value;
141 <            if (checkValue != ~(v ^ 0xAAAAAAAA))
141 >            if (checkValue != ~(v ^ 0xAAAAAAAA))
142                  ++failures;
143              return v;
144          }
# Line 147 | Line 147 | public final class UncheckedLockLoops {
147              setValue(initialValue);
148              this.iters = iters;
149              barrier = new CyclicBarrier(nthreads+1, timer);
150 <            for (int i = 0; i < nthreads; ++i)
150 >            for (int i = 0; i < nthreads; ++i)
151                  new Thread(this).start();
152              barrier.await();
153              barrier.await();
# Line 155 | Line 155 | public final class UncheckedLockLoops {
155              if (print) {
156                  long tpi = time / (iters * nthreads);
157                  System.out.print("\t" + LoopHelpers.rightJustify(tpi) + " ns per update");
158 <                //                double secs = (double)(time) / 1000000000.0;
158 >                //                double secs = (double) time / 1000000000.0;
159                  //                System.out.print("\t " + secs + "s run time");
160                  System.out.println();
161              }
# Line 168 | Line 168 | public final class UncheckedLockLoops {
168          abstract int loop(int n);
169          public final void run() {
170              try {
171 <                barrier.await();
171 >                barrier.await();
172                  result += loop(iters);
173                  barrier.await();
174              }
175 <            catch (Exception ie) {
176 <                return;
175 >            catch (Exception ie) {
176 >                return;
177              }
178          }
179  
# Line 183 | Line 183 | public final class UncheckedLockLoops {
183          private volatile int readBarrier;
184          final int loop(int n) {
185              int sum = 0;
186 <            int x = 0;;
186 >            int x = 0;
187              while (n-- > 0) {
188                  int r1 = readBarrier;
189                  x = setValue(LoopHelpers.compute1(getValue()));
# Line 199 | Line 199 | public final class UncheckedLockLoops {
199      private static class BuiltinLockLoop extends LockLoop {
200          final int loop(int n) {
201              int sum = 0;
202 <            int x = 0;;
202 >            int x = 0;
203              while (n-- > 0) {
204 <                synchronized(this) {
204 >                synchronized (this) {
205                      x = setValue(LoopHelpers.compute1(getValue()));
206                  }
207                  sum += LoopHelpers.compute2(x);
# Line 211 | Line 211 | public final class UncheckedLockLoops {
211      }
212  
213      private static class ReentrantLockLoop extends LockLoop {
214 <        final private ReentrantLock lock = new ReentrantLock();
214 >        private final ReentrantLock lock = new ReentrantLock();
215          final int loop(int n) {
216              final ReentrantLock lock = this.lock;
217              int sum = 0;
# Line 231 | Line 231 | public final class UncheckedLockLoops {
231      }
232  
233      private static class MutexLoop extends LockLoop {
234 <        final private Mutex lock = new Mutex();
234 >        private final Mutex lock = new Mutex();
235          final int loop(int n) {
236              final Mutex lock = this.lock;
237              int sum = 0;
# Line 251 | Line 251 | public final class UncheckedLockLoops {
251      }
252  
253      private static class LongMutexLoop extends LockLoop {
254 <        final private LongMutex lock = new LongMutex();
254 >        private final LongMutex lock = new LongMutex();
255          final int loop(int n) {
256              final LongMutex lock = this.lock;
257              int sum = 0;
# Line 271 | Line 271 | public final class UncheckedLockLoops {
271      }
272  
273      private static class FairReentrantLockLoop extends LockLoop {
274 <        final private ReentrantLock lock = new ReentrantLock(true);
274 >        private final ReentrantLock lock = new ReentrantLock(true);
275          final int loop(int n) {
276              final ReentrantLock lock = this.lock;
277              int sum = 0;
# Line 291 | Line 291 | public final class UncheckedLockLoops {
291      }
292  
293      private static class ReentrantWriteLockLoop extends LockLoop {
294 <        final private Lock lock = new ReentrantReadWriteLock().writeLock();
294 >        private final Lock lock = new ReentrantReadWriteLock().writeLock();
295          final int loop(int n) {
296              final Lock lock = this.lock;
297              int sum = 0;
# Line 331 | Line 331 | public final class UncheckedLockLoops {
331      }
332  
333      private static class SemaphoreLoop extends LockLoop {
334 <        final private Semaphore sem = new Semaphore(1, false);
334 >        private final Semaphore sem = new Semaphore(1, false);
335          final int loop(int n) {
336              final Semaphore sem = this.sem;
337              int sum = 0;
# Line 350 | Line 350 | public final class UncheckedLockLoops {
350          }
351      }
352      private static class FairSemaphoreLoop extends LockLoop {
353 <        final private Semaphore sem = new Semaphore(1, true);
353 >        private final Semaphore sem = new Semaphore(1, true);
354          final int loop(int n) {
355              final Semaphore sem = this.sem;
356              int sum = 0;
# Line 370 | Line 370 | public final class UncheckedLockLoops {
370      }
371  
372      private static class ReentrantReadWriteLockLoop extends LockLoop {
373 <        final private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
373 >        private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
374          final int loop(int n) {
375              final Lock rlock = lock.readLock();
376              final Lock wlock = lock.writeLock();
# Line 403 | Line 403 | public final class UncheckedLockLoops {
403  
404      }
405  
406 –
406      private static class FairReentrantReadWriteLockLoop extends LockLoop {
407 <        final private ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
407 >        private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
408          final int loop(int n) {
409              final Lock rlock = lock.readLock();
410              final Lock wlock = lock.writeLock();

Diff Legend

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