[cvs] / jsr166 / src / test / tck / AbstractQueuedSynchronizerTest.java Repository:
ViewVC logotype

Diff of /jsr166/src/test/tck/AbstractQueuedSynchronizerTest.java

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.15, Sat Jan 10 20:37:20 2004 UTC revision 1.16, Sun Jan 11 16:02:33 2004 UTC
# Line 30  Line 30 
30       * ReentrantReadWriteLock, and Semaphore       * ReentrantReadWriteLock, and Semaphore
31       */       */
32      static class Mutex extends AbstractQueuedSynchronizer {      static class Mutex extends AbstractQueuedSynchronizer {
33          public boolean isLocked() { return getState() == 1; }          public boolean isHeldExclusively() { return getState() == 1; }
34    
35          public boolean tryAcquireExclusive(int acquires) {          public boolean tryAcquire(int acquires) {
36              assertTrue(acquires == 1);              assertTrue(acquires == 1);
37              return compareAndSetState(0, 1);              return compareAndSetState(0, 1);
38          }          }
39    
40          public boolean tryReleaseExclusive(int releases) {          public boolean tryRelease(int releases) {
41                if (getState() == 0) throw new IllegalMonitorStateException();
42              setState(0);              setState(0);
43              return true;              return true;
44          }          }
45    
         public void checkConditionAccess(Thread thread) {  
             if (getState() == 0) throw new IllegalMonitorStateException();  
         }  
   
46          public AbstractQueuedSynchronizer.ConditionObject newCondition() { return new AbstractQueuedSynchronizer.ConditionObject(); }          public AbstractQueuedSynchronizer.ConditionObject newCondition() { return new AbstractQueuedSynchronizer.ConditionObject(); }
47    
48          public void lock() {          public void lock() {
49              acquireExclusiveUninterruptibly(1);              acquire(1);
50          }          }
51    
52      }      }
# Line 72  Line 69 
69      }      }
70    
71      /**      /**
72       * A runnable calling acquireExclusiveInterruptibly       * A runnable calling acquireInterruptibly
73       */       */
74      class InterruptibleLockRunnable implements Runnable {      class InterruptibleLockRunnable implements Runnable {
75          final Mutex lock;          final Mutex lock;
76          InterruptibleLockRunnable(Mutex l) { lock = l; }          InterruptibleLockRunnable(Mutex l) { lock = l; }
77          public void run() {          public void run() {
78              try {              try {
79                  lock.acquireExclusiveInterruptibly(1);                  lock.acquireInterruptibly(1);
80              } catch(InterruptedException success){}              } catch(InterruptedException success){}
81          }          }
82      }      }
83    
84    
85      /**      /**
86       * A runnable calling acquireExclusiveInterruptibly that expects to be       * A runnable calling acquireInterruptibly that expects to be
87       * interrupted       * interrupted
88       */       */
89      class InterruptedLockRunnable implements Runnable {      class InterruptedLockRunnable implements Runnable {
# Line 94  Line 91 
91          InterruptedLockRunnable(Mutex l) { lock = l; }          InterruptedLockRunnable(Mutex l) { lock = l; }
92          public void run() {          public void run() {
93              try {              try {
94                  lock.acquireExclusiveInterruptibly(1);                  lock.acquireInterruptibly(1);
95                  threadShouldThrow();                  threadShouldThrow();
96              } catch(InterruptedException success){}              } catch(InterruptedException success){}
97          }          }
98      }      }
99    
100      /**      /**
101       * acquireExclusiveUninterruptiblying an releaseExclusiveed lock succeeds       * isHeldExclusively is false upon construction
102         */
103        public void testIsHeldExclusively() {
104            Mutex rl = new Mutex();
105            assertFalse(rl.isHeldExclusively());
106        }
107    
108        /**
109         * acquiring released lock succeeds
110       */       */
111      public void testAcquireExclusiveUninterruptibly() {      public void testAcquire() {
112          Mutex rl = new Mutex();          Mutex rl = new Mutex();
113          rl.acquireExclusiveUninterruptibly(1);          rl.acquire(1);
114          assertTrue(rl.isLocked());          assertTrue(rl.isHeldExclusively());
115          rl.releaseExclusive(1);          rl.release(1);
116      }      }
117    
118      /**      /**
119       * tryAcquireExclusive on an releaseExclusiveed lock succeeds       * tryAcquire on an released lock succeeds
120       */       */
121      public void testTryAcquireExclusive() {      public void testTryAcquire() {
122          Mutex rl = new Mutex();          Mutex rl = new Mutex();
123          assertTrue(rl.tryAcquireExclusive(1));          assertTrue(rl.tryAcquire(1));
124          assertTrue(rl.isLocked());          assertTrue(rl.isHeldExclusively());
125          rl.releaseExclusive(1);          rl.release(1);
126      }      }
127    
128      /**      /**
# Line 129  Line 134 
134          Thread t2 = new Thread(new InterruptibleLockRunnable(lock));          Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
135          try {          try {
136              assertFalse(lock.hasQueuedThreads());              assertFalse(lock.hasQueuedThreads());
137              lock.acquireExclusiveUninterruptibly(1);              lock.acquire(1);
138              t1.start();              t1.start();
139              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
140              assertTrue(lock.hasQueuedThreads());              assertTrue(lock.hasQueuedThreads());
# Line 139  Line 144 
144              t1.interrupt();              t1.interrupt();
145              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
146              assertTrue(lock.hasQueuedThreads());              assertTrue(lock.hasQueuedThreads());
147              lock.releaseExclusive(1);              lock.release(1);
148              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
149              assertFalse(lock.hasQueuedThreads());              assertFalse(lock.hasQueuedThreads());
150              t1.join();              t1.join();
# Line 171  Line 176 
176          try {          try {
177              assertFalse(lock.isQueued(t1));              assertFalse(lock.isQueued(t1));
178              assertFalse(lock.isQueued(t2));              assertFalse(lock.isQueued(t2));
179              lock.acquireExclusiveUninterruptibly(1);              lock.acquire(1);
180              t1.start();              t1.start();
181              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
182              assertTrue(lock.isQueued(t1));              assertTrue(lock.isQueued(t1));
# Line 183  Line 188 
188              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
189              assertFalse(lock.isQueued(t1));              assertFalse(lock.isQueued(t1));
190              assertTrue(lock.isQueued(t2));              assertTrue(lock.isQueued(t2));
191              lock.releaseExclusive(1);              lock.release(1);
192              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
193              assertFalse(lock.isQueued(t1));              assertFalse(lock.isQueued(t1));
194              assertFalse(lock.isQueued(t2));              assertFalse(lock.isQueued(t2));
# Line 203  Line 208 
208          Thread t2 = new Thread(new InterruptibleLockRunnable(lock));          Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
209          try {          try {
210              assertNull(lock.getFirstQueuedThread());              assertNull(lock.getFirstQueuedThread());
211              lock.acquireExclusiveUninterruptibly(1);              lock.acquire(1);
212              t1.start();              t1.start();
213              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
214              assertEquals(t1, lock.getFirstQueuedThread());              assertEquals(t1, lock.getFirstQueuedThread());
# Line 213  Line 218 
218              t1.interrupt();              t1.interrupt();
219              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
220              assertEquals(t2, lock.getFirstQueuedThread());              assertEquals(t2, lock.getFirstQueuedThread());
221              lock.releaseExclusive(1);              lock.release(1);
222              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
223              assertNull(lock.getFirstQueuedThread());              assertNull(lock.getFirstQueuedThread());
224              t1.join();              t1.join();
# Line 233  Line 238 
238          Thread t2 = new Thread(new InterruptibleLockRunnable(lock));          Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
239          try {          try {
240              assertFalse(lock.hasContended());              assertFalse(lock.hasContended());
241              lock.acquireExclusiveUninterruptibly(1);              lock.acquire(1);
242              t1.start();              t1.start();
243              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
244              assertTrue(lock.hasContended());              assertTrue(lock.hasContended());
# Line 243  Line 248 
248              t1.interrupt();              t1.interrupt();
249              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
250              assertTrue(lock.hasContended());              assertTrue(lock.hasContended());
251              lock.releaseExclusive(1);              lock.release(1);
252              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
253              assertTrue(lock.hasContended());              assertTrue(lock.hasContended());
254              t1.join();              t1.join();
# Line 254  Line 259 
259      }      }
260    
261      /**      /**
262       * acquireExclusiveNanos is interruptible.       * tryAcquireNanos is interruptible.
263       */       */
264      public void testInterruptedException2() {      public void testInterruptedException2() {
265          final Mutex lock = new Mutex();          final Mutex lock = new Mutex();
266          lock.acquireExclusiveUninterruptibly(1);          lock.acquire(1);
267          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
268                  public void run() {                  public void run() {
269                      try {                      try {
270                          lock.acquireExclusiveNanos(1, MEDIUM_DELAY_MS * 1000 * 1000);                          lock.tryAcquireNanos(1, MEDIUM_DELAY_MS * 1000 * 1000);
271                          threadShouldThrow();                          threadShouldThrow();
272                      } catch(InterruptedException success){}                      } catch(InterruptedException success){}
273                  }                  }
# Line 277  Line 282 
282    
283    
284      /**      /**
285       * TryAcquireExclusive on a locked lock fails       * TryAcquire on a locked lock fails
286       */       */
287      public void testTryAcquireExclusiveWhenLocked() {      public void testTryAcquireWhenLocked() {
288          final Mutex lock = new Mutex();          final Mutex lock = new Mutex();
289          lock.acquireExclusiveUninterruptibly(1);          lock.acquire(1);
290          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
291                  public void run() {                  public void run() {
292                      threadAssertFalse(lock.tryAcquireExclusive(1));                      threadAssertFalse(lock.tryAcquire(1));
293                  }                  }
294              });              });
295          try {          try {
296              t.start();              t.start();
297              t.join();              t.join();
298              lock.releaseExclusive(1);              lock.release(1);
299          } catch(Exception e){          } catch(Exception e){
300              unexpectedException();              unexpectedException();
301          }          }
302      }      }
303    
304      /**      /**
305       * acquireExclusiveNanos on a locked lock times out       * tryAcquireNanos on a locked lock times out
306       */       */
307      public void testAcquireExclusiveNanos_Timeout() {      public void testAcquireNanos_Timeout() {
308          final Mutex lock = new Mutex();          final Mutex lock = new Mutex();
309          lock.acquireExclusiveUninterruptibly(1);          lock.acquire(1);
310          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
311                  public void run() {                  public void run() {
312                      try {                      try {
313                          threadAssertFalse(lock.acquireExclusiveNanos(1, 1000 * 1000));                          threadAssertFalse(lock.tryAcquireNanos(1, 1000 * 1000));
314                      } catch (Exception ex) {                      } catch (Exception ex) {
315                          threadUnexpectedException();                          threadUnexpectedException();
316                      }                      }
# Line 314  Line 319 
319          try {          try {
320              t.start();              t.start();
321              t.join();              t.join();
322              lock.releaseExclusive(1);              lock.release(1);
323          } catch(Exception e){          } catch(Exception e){
324              unexpectedException();              unexpectedException();
325          }          }
# Line 326  Line 331 
331       */       */
332      public void testGetState() {      public void testGetState() {
333          final Mutex lock = new Mutex();          final Mutex lock = new Mutex();
334          lock.acquireExclusiveUninterruptibly(1);          lock.acquire(1);
335          assertTrue(lock.isLocked());          assertTrue(lock.isHeldExclusively());
336          lock.releaseExclusive(1);          lock.release(1);
337          assertFalse(lock.isLocked());          assertFalse(lock.isHeldExclusively());
338          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
339                  public void run() {                  public void run() {
340                      lock.acquireExclusiveUninterruptibly(1);                      lock.acquire(1);
341                      try {                      try {
342                          Thread.sleep(SMALL_DELAY_MS);                          Thread.sleep(SMALL_DELAY_MS);
343                      }                      }
344                      catch(Exception e) {                      catch(Exception e) {
345                          threadUnexpectedException();                          threadUnexpectedException();
346                      }                      }
347                      lock.releaseExclusive(1);                      lock.release(1);
348                  }                  }
349              });              });
350          try {          try {
351              t.start();              t.start();
352              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
353              assertTrue(lock.isLocked());              assertTrue(lock.isHeldExclusively());
354              t.join();              t.join();
355              assertFalse(lock.isLocked());              assertFalse(lock.isHeldExclusively());
356          } catch(Exception e){          } catch(Exception e){
357              unexpectedException();              unexpectedException();
358          }          }
# Line 355  Line 360 
360    
361    
362      /**      /**
363       * acquireExclusiveInterruptibly is interruptible.       * acquireInterruptibly is interruptible.
364       */       */
365      public void testAcquireInterruptibly1() {      public void testAcquireInterruptibly1() {
366          final Mutex lock = new Mutex();          final Mutex lock = new Mutex();
367          lock.acquireExclusiveUninterruptibly(1);          lock.acquire(1);
368          Thread t = new Thread(new InterruptedLockRunnable(lock));          Thread t = new Thread(new InterruptedLockRunnable(lock));
369          try {          try {
370              t.start();              t.start();
371              t.interrupt();              t.interrupt();
372              lock.releaseExclusive(1);              lock.release(1);
373              t.join();              t.join();
374          } catch(Exception e){          } catch(Exception e){
375              unexpectedException();              unexpectedException();
# Line 372  Line 377 
377      }      }
378    
379      /**      /**
380       * acquireExclusiveInterruptibly succeeds when released, else is interruptible       * acquireInterruptibly succeeds when released, else is interruptible
381       */       */
382      public void testAcquireInterruptibly2() {      public void testAcquireInterruptibly2() {
383          final Mutex lock = new Mutex();          final Mutex lock = new Mutex();
384          try {          try {
385              lock.acquireExclusiveInterruptibly(1);              lock.acquireInterruptibly(1);
386          } catch(Exception e) {          } catch(Exception e) {
387              unexpectedException();              unexpectedException();
388          }          }
# Line 385  Line 390 
390          try {          try {
391              t.start();              t.start();
392              t.interrupt();              t.interrupt();
393              assertTrue(lock.isLocked());              assertTrue(lock.isHeldExclusively());
394              t.join();              t.join();
395          } catch(Exception e){          } catch(Exception e){
396              unexpectedException();              unexpectedException();
# Line 444  Line 449 
449          final Mutex lock = new Mutex();          final Mutex lock = new Mutex();
450          final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();
451          try {          try {
452              lock.acquireExclusiveUninterruptibly(1);              lock.acquire(1);
453              long t = c.awaitNanos(100);              long t = c.awaitNanos(100);
454              assertTrue(t <= 0);              assertTrue(t <= 0);
455              lock.releaseExclusive(1);              lock.release(1);
456          }          }
457          catch (Exception ex) {          catch (Exception ex) {
458              unexpectedException();              unexpectedException();
# Line 461  Line 466 
466          final Mutex lock = new Mutex();          final Mutex lock = new Mutex();
467          final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();
468          try {          try {
469              lock.acquireExclusiveUninterruptibly(1);              lock.acquire(1);
470              assertFalse(c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));              assertFalse(c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
471              lock.releaseExclusive(1);              lock.release(1);
472          }          }
473          catch (Exception ex) {          catch (Exception ex) {
474              unexpectedException();              unexpectedException();
# Line 477  Line 482 
482          final Mutex lock = new Mutex();          final Mutex lock = new Mutex();
483          final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();
484          try {          try {
485              lock.acquireExclusiveUninterruptibly(1);              lock.acquire(1);
486              java.util.Date d = new java.util.Date();              java.util.Date d = new java.util.Date();
487              assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));              assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));
488              lock.releaseExclusive(1);              lock.release(1);
489          }          }
490          catch (Exception ex) {          catch (Exception ex) {
491              unexpectedException();              unexpectedException();
# Line 496  Line 501 
501          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
502                  public void run() {                  public void run() {
503                      try {                      try {
504                          lock.acquireExclusiveUninterruptibly(1);                          lock.acquire(1);
505                          c.await();                          c.await();
506                          lock.releaseExclusive(1);                          lock.release(1);
507                      }                      }
508                      catch(InterruptedException e) {                      catch(InterruptedException e) {
509                          threadUnexpectedException();                          threadUnexpectedException();
# Line 509  Line 514 
514          try {          try {
515              t.start();              t.start();
516              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
517              lock.acquireExclusiveUninterruptibly(1);              lock.acquire(1);
518              c.signal();              c.signal();
519              lock.releaseExclusive(1);              lock.release(1);
520              t.join(SHORT_DELAY_MS);              t.join(SHORT_DELAY_MS);
521              assertFalse(t.isAlive());              assertFalse(t.isAlive());
522          }          }
# Line 672  Line 677 
677          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
678                  public void run() {                  public void run() {
679                      try {                      try {
680                          lock.acquireExclusiveUninterruptibly(1);                          lock.acquire(1);
681                          threadAssertFalse(lock.hasWaiters(c));                          threadAssertFalse(lock.hasWaiters(c));
682                          threadAssertEquals(0, lock.getWaitQueueLength(c));                          threadAssertEquals(0, lock.getWaitQueueLength(c));
683                          c.await();                          c.await();
684                          lock.releaseExclusive(1);                          lock.release(1);
685                      }                      }
686                      catch(InterruptedException e) {                      catch(InterruptedException e) {
687                          threadUnexpectedException();                          threadUnexpectedException();
# Line 687  Line 692 
692          try {          try {
693              t.start();              t.start();
694              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
695              lock.acquireExclusiveUninterruptibly(1);              lock.acquire(1);
696              assertTrue(lock.hasWaiters(c));              assertTrue(lock.hasWaiters(c));
697              assertEquals(1, lock.getWaitQueueLength(c));              assertEquals(1, lock.getWaitQueueLength(c));
698              c.signal();              c.signal();
699              lock.releaseExclusive(1);              lock.release(1);
700              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
701              lock.acquireExclusiveUninterruptibly(1);              lock.acquire(1);
702              assertFalse(lock.hasWaiters(c));              assertFalse(lock.hasWaiters(c));
703              assertEquals(0, lock.getWaitQueueLength(c));              assertEquals(0, lock.getWaitQueueLength(c));
704              lock.releaseExclusive(1);              lock.release(1);
705              t.join(SHORT_DELAY_MS);              t.join(SHORT_DELAY_MS);
706              assertFalse(t.isAlive());              assertFalse(t.isAlive());
707          }          }
# Line 714  Line 719 
719          Thread t1 = new Thread(new Runnable() {          Thread t1 = new Thread(new Runnable() {
720                  public void run() {                  public void run() {
721                      try {                      try {
722                          lock.acquireExclusiveUninterruptibly(1);                          lock.acquire(1);
723                          threadAssertFalse(lock.hasWaiters(c));                          threadAssertFalse(lock.hasWaiters(c));
724                          threadAssertEquals(0, lock.getWaitQueueLength(c));                          threadAssertEquals(0, lock.getWaitQueueLength(c));
725                          c.await();                          c.await();
726                          lock.releaseExclusive(1);                          lock.release(1);
727                      }                      }
728                      catch(InterruptedException e) {                      catch(InterruptedException e) {
729                          threadUnexpectedException();                          threadUnexpectedException();
# Line 729  Line 734 
734          Thread t2 = new Thread(new Runnable() {          Thread t2 = new Thread(new Runnable() {
735                  public void run() {                  public void run() {
736                      try {                      try {
737                          lock.acquireExclusiveUninterruptibly(1);                          lock.acquire(1);
738                          threadAssertTrue(lock.hasWaiters(c));                          threadAssertTrue(lock.hasWaiters(c));
739                          threadAssertEquals(1, lock.getWaitQueueLength(c));                          threadAssertEquals(1, lock.getWaitQueueLength(c));
740                          c.await();                          c.await();
741                          lock.releaseExclusive(1);                          lock.release(1);
742                      }                      }
743                      catch(InterruptedException e) {                      catch(InterruptedException e) {
744                          threadUnexpectedException();                          threadUnexpectedException();
# Line 746  Line 751 
751              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
752              t2.start();              t2.start();
753              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
754              lock.acquireExclusiveUninterruptibly(1);              lock.acquire(1);
755              assertTrue(lock.hasWaiters(c));              assertTrue(lock.hasWaiters(c));
756              assertEquals(2, lock.getWaitQueueLength(c));              assertEquals(2, lock.getWaitQueueLength(c));
757              c.signalAll();              c.signalAll();
758              lock.releaseExclusive(1);              lock.release(1);
759              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
760              lock.acquireExclusiveUninterruptibly(1);              lock.acquire(1);
761              assertFalse(lock.hasWaiters(c));              assertFalse(lock.hasWaiters(c));
762              assertEquals(0, lock.getWaitQueueLength(c));              assertEquals(0, lock.getWaitQueueLength(c));
763              lock.releaseExclusive(1);              lock.release(1);
764              t1.join(SHORT_DELAY_MS);              t1.join(SHORT_DELAY_MS);
765              t2.join(SHORT_DELAY_MS);              t2.join(SHORT_DELAY_MS);
766              assertFalse(t1.isAlive());              assertFalse(t1.isAlive());
# Line 775  Line 780 
780          Thread t1 = new Thread(new Runnable() {          Thread t1 = new Thread(new Runnable() {
781                  public void run() {                  public void run() {
782                      try {                      try {
783                          lock.acquireExclusiveUninterruptibly(1);                          lock.acquire(1);
784                          threadAssertTrue(lock.getWaitingThreads(c).isEmpty());                          threadAssertTrue(lock.getWaitingThreads(c).isEmpty());
785                          c.await();                          c.await();
786                          lock.releaseExclusive(1);                          lock.release(1);
787                      }                      }
788                      catch(InterruptedException e) {                      catch(InterruptedException e) {
789                          threadUnexpectedException();                          threadUnexpectedException();
# Line 789  Line 794 
794          Thread t2 = new Thread(new Runnable() {          Thread t2 = new Thread(new Runnable() {
795                  public void run() {                  public void run() {
796                      try {                      try {
797                          lock.acquireExclusiveUninterruptibly(1);                          lock.acquire(1);
798                          threadAssertFalse(lock.getWaitingThreads(c).isEmpty());                          threadAssertFalse(lock.getWaitingThreads(c).isEmpty());
799                          c.await();                          c.await();
800                          lock.releaseExclusive(1);                          lock.release(1);
801                      }                      }
802                      catch(InterruptedException e) {                      catch(InterruptedException e) {
803                          threadUnexpectedException();                          threadUnexpectedException();
# Line 801  Line 806 
806              });              });
807    
808          try {          try {
809              lock.acquireExclusiveUninterruptibly(1);              lock.acquire(1);
810              assertTrue(lock.getWaitingThreads(c).isEmpty());              assertTrue(lock.getWaitingThreads(c).isEmpty());
811              lock.releaseExclusive(1);              lock.release(1);
812              t1.start();              t1.start();
813              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
814              t2.start();              t2.start();
815              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
816              lock.acquireExclusiveUninterruptibly(1);              lock.acquire(1);
817              assertTrue(lock.hasWaiters(c));              assertTrue(lock.hasWaiters(c));
818              assertTrue(lock.getWaitingThreads(c).contains(t1));              assertTrue(lock.getWaitingThreads(c).contains(t1));
819              assertTrue(lock.getWaitingThreads(c).contains(t2));              assertTrue(lock.getWaitingThreads(c).contains(t2));
820              c.signalAll();              c.signalAll();
821              lock.releaseExclusive(1);              lock.release(1);
822              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
823              lock.acquireExclusiveUninterruptibly(1);              lock.acquire(1);
824              assertFalse(lock.hasWaiters(c));              assertFalse(lock.hasWaiters(c));
825              assertTrue(lock.getWaitingThreads(c).isEmpty());              assertTrue(lock.getWaitingThreads(c).isEmpty());
826              lock.releaseExclusive(1);              lock.release(1);
827              t1.join(SHORT_DELAY_MS);              t1.join(SHORT_DELAY_MS);
828              t2.join(SHORT_DELAY_MS);              t2.join(SHORT_DELAY_MS);
829              assertFalse(t1.isAlive());              assertFalse(t1.isAlive());
# Line 839  Line 844 
844          final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();
845          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
846                  public void run() {                  public void run() {
847                      lock.acquireExclusiveUninterruptibly(1);                      lock.acquire(1);
848                      c.awaitUninterruptibly();                      c.awaitUninterruptibly();
849                      lock.releaseExclusive(1);                      lock.release(1);
850                  }                  }
851              });              });
852    
# Line 849  Line 854 
854              t.start();              t.start();
855              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
856              t.interrupt();              t.interrupt();
857              lock.acquireExclusiveUninterruptibly(1);              lock.acquire(1);
858              c.signal();              c.signal();
859              lock.releaseExclusive(1);              lock.release(1);
860              assert(t.isInterrupted());              assert(t.isInterrupted());
861              t.join(SHORT_DELAY_MS);              t.join(SHORT_DELAY_MS);
862              assertFalse(t.isAlive());              assertFalse(t.isAlive());
# Line 870  Line 875 
875          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
876                  public void run() {                  public void run() {
877                      try {                      try {
878                          lock.acquireExclusiveUninterruptibly(1);                          lock.acquire(1);
879                          c.await();                          c.await();
880                          lock.releaseExclusive(1);                          lock.release(1);
881                          threadShouldThrow();                          threadShouldThrow();
882                      }                      }
883                      catch(InterruptedException success) {                      catch(InterruptedException success) {
# Line 901  Line 906 
906          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
907                  public void run() {                  public void run() {
908                      try {                      try {
909                          lock.acquireExclusiveUninterruptibly(1);                          lock.acquire(1);
910                          c.awaitNanos(1000 * 1000 * 1000); // 1 sec                          c.awaitNanos(1000 * 1000 * 1000); // 1 sec
911                          lock.releaseExclusive(1);                          lock.release(1);
912                          threadShouldThrow();                          threadShouldThrow();
913                      }                      }
914                      catch(InterruptedException success) {                      catch(InterruptedException success) {
# Line 932  Line 937 
937          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
938                  public void run() {                  public void run() {
939                      try {                      try {
940                          lock.acquireExclusiveUninterruptibly(1);                          lock.acquire(1);
941                          java.util.Date d = new java.util.Date();                          java.util.Date d = new java.util.Date();
942                          c.awaitUntil(new java.util.Date(d.getTime() + 10000));                          c.awaitUntil(new java.util.Date(d.getTime() + 10000));
943                          lock.releaseExclusive(1);                          lock.release(1);
944                          threadShouldThrow();                          threadShouldThrow();
945                      }                      }
946                      catch(InterruptedException success) {                      catch(InterruptedException success) {
# Line 964  Line 969 
969          Thread t1 = new Thread(new Runnable() {          Thread t1 = new Thread(new Runnable() {
970                  public void run() {                  public void run() {
971                      try {                      try {
972                          lock.acquireExclusiveUninterruptibly(1);                          lock.acquire(1);
973                          c.await();                          c.await();
974                          lock.releaseExclusive(1);                          lock.release(1);
975                      }                      }
976                      catch(InterruptedException e) {                      catch(InterruptedException e) {
977                          threadUnexpectedException();                          threadUnexpectedException();
# Line 977  Line 982 
982          Thread t2 = new Thread(new Runnable() {          Thread t2 = new Thread(new Runnable() {
983                  public void run() {                  public void run() {
984                      try {                      try {
985                          lock.acquireExclusiveUninterruptibly(1);                          lock.acquire(1);
986                          c.await();                          c.await();
987                          lock.releaseExclusive(1);                          lock.release(1);
988                      }                      }
989                      catch(InterruptedException e) {                      catch(InterruptedException e) {
990                          threadUnexpectedException();                          threadUnexpectedException();
# Line 991  Line 996 
996              t1.start();              t1.start();
997              t2.start();              t2.start();
998              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
999              lock.acquireExclusiveUninterruptibly(1);              lock.acquire(1);
1000              c.signalAll();              c.signalAll();
1001              lock.releaseExclusive(1);              lock.release(1);
1002              t1.join(SHORT_DELAY_MS);              t1.join(SHORT_DELAY_MS);
1003              t2.join(SHORT_DELAY_MS);              t2.join(SHORT_DELAY_MS);
1004              assertFalse(t1.isAlive());              assertFalse(t1.isAlive());
# Line 1012  Line 1017 
1017          Mutex lock = new Mutex();          Mutex lock = new Mutex();
1018          String us = lock.toString();          String us = lock.toString();
1019          assertTrue(us.indexOf("State = 0") >= 0);          assertTrue(us.indexOf("State = 0") >= 0);
1020          lock.acquireExclusiveUninterruptibly(1);          lock.acquire(1);
1021          String ls = lock.toString();          String ls = lock.toString();
1022          assertTrue(ls.indexOf("State = 1") >= 0);          assertTrue(ls.indexOf("State = 1") >= 0);
1023      }      }
# Line 1022  Line 1027 
1027       */       */
1028      public void testSerialization() {      public void testSerialization() {
1029          Mutex l = new Mutex();          Mutex l = new Mutex();
1030          l.acquireExclusiveUninterruptibly(1);          l.acquire(1);
1031          assertTrue(l.isLocked());          assertTrue(l.isHeldExclusively());
1032    
1033          try {          try {
1034              ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);              ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
# Line 1034  Line 1039 
1039              ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());              ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
1040              ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));              ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
1041              Mutex r = (Mutex) in.readObject();              Mutex r = (Mutex) in.readObject();
1042              assertTrue(r.isLocked());              assertTrue(r.isHeldExclusively());
1043          } catch(Exception e){          } catch(Exception e){
1044              e.printStackTrace();              e.printStackTrace();
1045              unexpectedException();              unexpectedException();
# Line 1104  Line 1109 
1109                  public void run() {                  public void run() {
1110                      try {                      try {
1111                          threadAssertFalse(l.isSignalled());                          threadAssertFalse(l.isSignalled());
1112                          threadAssertTrue(l.acquireSharedNanos(0, MEDIUM_DELAY_MS* 1000 * 1000));                          threadAssertTrue(l.tryAcquireSharedNanos(0, MEDIUM_DELAY_MS* 1000 * 1000));
1113                          threadAssertTrue(l.isSignalled());                          threadAssertTrue(l.isSignalled());
1114    
1115                      } catch(InterruptedException e){                      } catch(InterruptedException e){
# Line 1157  Line 1162 
1162                  public void run() {                  public void run() {
1163                      try {                      try {
1164                          threadAssertFalse(l.isSignalled());                          threadAssertFalse(l.isSignalled());
1165                          l.acquireSharedNanos(0, SMALL_DELAY_MS* 1000 * 1000);                          l.tryAcquireSharedNanos(0, SMALL_DELAY_MS* 1000 * 1000);
1166                          threadShouldThrow();                          threadShouldThrow();
1167                      } catch(InterruptedException success){}                      } catch(InterruptedException success){}
1168                  }                  }
# Line 1182  Line 1187 
1187                  public void run() {                  public void run() {
1188                      try {                      try {
1189                          threadAssertFalse(l.isSignalled());                          threadAssertFalse(l.isSignalled());
1190                          threadAssertFalse(l.acquireSharedNanos(0, SMALL_DELAY_MS* 1000 * 1000));                          threadAssertFalse(l.tryAcquireSharedNanos(0, SMALL_DELAY_MS* 1000 * 1000));
1191                      } catch(InterruptedException ie){                      } catch(InterruptedException ie){
1192                          threadUnexpectedException();                          threadUnexpectedException();
1193                      }                      }

Legend:
Removed from v.1.15  
changed lines
  Added in v.1.16

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8