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

Comparing jsr166/src/test/tck/AbstractQueuedSynchronizerTest.java (file contents):
Revision 1.6 by dl, Wed Dec 31 21:30:08 2003 UTC vs.
Revision 1.10 by dl, Wed Jan 7 20:49:53 2004 UTC

# Line 32 | Line 32 | public class AbstractQueuedSynchronizerT
32          private static class Sync extends AbstractQueuedSynchronizer {
33              boolean isLocked() { return getState() == 1; }
34  
35 <            public boolean tryAcquireExclusiveState(boolean isQueued, int acquires) {
35 >            public boolean tryAcquireExclusive(int acquires) {
36                  assert acquires == 1; // Does not use multiple acquires
37                  return compareAndSetState(0, 1);
38              }
39              
40 <            public boolean releaseExclusiveState(int releases) {
40 >            public boolean tryReleaseExclusive(int releases) {
41                  setState(0);
42                  return true;
43              }
44              
45 <            public void checkConditionAccess(Thread thread, boolean waiting) {
45 >            public void checkConditionAccess(Thread thread) {
46                  if (getState() == 0) throw new IllegalMonitorStateException();
47              }
48              
# Line 52 | Line 52 | public class AbstractQueuedSynchronizerT
52                  s.defaultReadObject();
53                  setState(0); // reset to unlocked state
54              }
55 +
56          }
57 <        
57 >        
58          private final Sync sync = new Sync();
59          public boolean tryLock() {
60 <            return sync.tryAcquireExclusiveState(false, 1);
60 >            return sync.tryAcquireExclusive(1);
61          }
62          public void lock() {
63              sync.acquireExclusiveUninterruptibly(1);
# Line 71 | Line 72 | public class AbstractQueuedSynchronizerT
72          public Condition newCondition() { return sync.newCondition(); }
73          public boolean isLocked() { return sync.isLocked(); }
74          public boolean hasQueuedThreads() { return sync.hasQueuedThreads(); }
75 +        public boolean hasContended() { return sync.hasContended(); }
76 +        public boolean isQueued(Thread t) { return sync.isQueued(t); }
77      }
78  
79      /**
# Line 147 | Line 150 | public class AbstractQueuedSynchronizerT
150              t1.join();
151              t2.join();
152          } catch(Exception e){
153 +            unexpectedException();
154 +        }
155 +    }
156 +
157 +    /**
158 +     * isQueued reports whether a thread is queued.
159 +     */
160 +    public void testIsQueued() {
161 +        final Mutex lock = new Mutex();
162 +        Thread t1 = new Thread(new InterruptedLockRunnable(lock));
163 +        Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
164 +        try {
165 +            assertFalse(lock.isQueued(t1));
166 +            assertFalse(lock.isQueued(t2));
167 +            lock.lock();
168 +            t1.start();
169 +            Thread.sleep(SHORT_DELAY_MS);
170 +            assertTrue(lock.isQueued(t1));
171 +            t2.start();
172 +            Thread.sleep(SHORT_DELAY_MS);
173 +            assertTrue(lock.isQueued(t1));
174 +            assertTrue(lock.isQueued(t2));
175 +            t1.interrupt();
176 +            Thread.sleep(SHORT_DELAY_MS);
177 +            assertFalse(lock.isQueued(t1));
178 +            assertTrue(lock.isQueued(t2));
179 +            lock.unlock();
180 +            Thread.sleep(SHORT_DELAY_MS);
181 +            assertFalse(lock.isQueued(t1));
182 +            assertFalse(lock.isQueued(t2));
183 +            t1.join();
184 +            t2.join();
185 +        } catch(Exception e){
186 +            unexpectedException();
187 +        }
188 +    }
189 +
190 +
191 +    /**
192 +     * hasContended reports whether there has been contention
193 +     */
194 +    public void testhasContended() {
195 +        final Mutex lock = new Mutex();
196 +        Thread t1 = new Thread(new InterruptedLockRunnable(lock));
197 +        Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
198 +        try {
199 +            assertFalse(lock.hasContended());
200 +            lock.lock();
201 +            t1.start();
202 +            Thread.sleep(SHORT_DELAY_MS);
203 +            assertTrue(lock.hasContended());
204 +            t2.start();
205 +            Thread.sleep(SHORT_DELAY_MS);
206 +            assertTrue(lock.hasContended());
207 +            t1.interrupt();
208 +            Thread.sleep(SHORT_DELAY_MS);
209 +            assertTrue(lock.hasContended());
210 +            lock.unlock();
211 +            Thread.sleep(SHORT_DELAY_MS);
212 +            assertTrue(lock.hasContended());
213 +            t1.join();
214 +            t2.join();
215 +        } catch(Exception e){
216              unexpectedException();
217          }
218      }

Diff Legend

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