29 |
|
public void run() { |
30 |
|
try { |
31 |
|
lock.lockInterruptibly(); |
32 |
< |
} catch(InterruptedException success){} |
32 |
> |
} catch (InterruptedException success){} |
33 |
|
} |
34 |
|
} |
35 |
|
|
45 |
|
try { |
46 |
|
lock.lockInterruptibly(); |
47 |
|
threadShouldThrow(); |
48 |
< |
} catch(InterruptedException success){} |
48 |
> |
} catch (InterruptedException success){} |
49 |
|
} |
50 |
|
} |
51 |
|
|
103 |
|
rl.unlock(); |
104 |
|
shouldThrow(); |
105 |
|
|
106 |
< |
} catch(IllegalMonitorStateException success){} |
106 |
> |
} catch (IllegalMonitorStateException success){} |
107 |
|
} |
108 |
|
|
109 |
|
/** |
141 |
|
assertFalse(lock.hasQueuedThreads()); |
142 |
|
t1.join(); |
143 |
|
t2.join(); |
144 |
< |
} catch(Exception e){ |
144 |
> |
} catch (Exception e){ |
145 |
|
unexpectedException(); |
146 |
|
} |
147 |
|
} |
170 |
|
assertEquals(0, lock.getQueueLength()); |
171 |
|
t1.join(); |
172 |
|
t2.join(); |
173 |
< |
} catch(Exception e){ |
173 |
> |
} catch (Exception e){ |
174 |
|
unexpectedException(); |
175 |
|
} |
176 |
|
} |
199 |
|
assertEquals(0, lock.getQueueLength()); |
200 |
|
t1.join(); |
201 |
|
t2.join(); |
202 |
< |
} catch(Exception e){ |
202 |
> |
} catch (Exception e){ |
203 |
|
unexpectedException(); |
204 |
|
} |
205 |
|
} |
245 |
|
assertFalse(sync.hasQueuedThread(t2)); |
246 |
|
t1.join(); |
247 |
|
t2.join(); |
248 |
< |
} catch(Exception e){ |
248 |
> |
} catch (Exception e){ |
249 |
|
unexpectedException(); |
250 |
|
} |
251 |
|
} |
278 |
|
assertTrue(lock.getQueuedThreads().isEmpty()); |
279 |
|
t1.join(); |
280 |
|
t2.join(); |
281 |
< |
} catch(Exception e){ |
281 |
> |
} catch (Exception e){ |
282 |
|
unexpectedException(); |
283 |
|
} |
284 |
|
} |
295 |
|
try { |
296 |
|
lock.tryLock(MEDIUM_DELAY_MS,TimeUnit.MILLISECONDS); |
297 |
|
threadShouldThrow(); |
298 |
< |
} catch(InterruptedException success){} |
298 |
> |
} catch (InterruptedException success){} |
299 |
|
} |
300 |
|
}); |
301 |
|
try { |
302 |
|
t.start(); |
303 |
|
t.interrupt(); |
304 |
< |
} catch(Exception e){ |
304 |
> |
} catch (Exception e){ |
305 |
|
unexpectedException(); |
306 |
|
} |
307 |
|
} |
322 |
|
t.start(); |
323 |
|
t.join(); |
324 |
|
lock.unlock(); |
325 |
< |
} catch(Exception e){ |
325 |
> |
} catch (Exception e){ |
326 |
|
unexpectedException(); |
327 |
|
} |
328 |
|
} |
346 |
|
t.start(); |
347 |
|
t.join(); |
348 |
|
lock.unlock(); |
349 |
< |
} catch(Exception e){ |
349 |
> |
} catch (Exception e){ |
350 |
|
unexpectedException(); |
351 |
|
} |
352 |
|
} |
356 |
|
*/ |
357 |
|
public void testGetHoldCount() { |
358 |
|
ReentrantLock lock = new ReentrantLock(); |
359 |
< |
for(int i = 1; i <= SIZE; i++) { |
359 |
> |
for (int i = 1; i <= SIZE; i++) { |
360 |
|
lock.lock(); |
361 |
|
assertEquals(i,lock.getHoldCount()); |
362 |
|
} |
363 |
< |
for(int i = SIZE; i > 0; i--) { |
363 |
> |
for (int i = SIZE; i > 0; i--) { |
364 |
|
lock.unlock(); |
365 |
|
assertEquals(i-1,lock.getHoldCount()); |
366 |
|
} |
382 |
|
try { |
383 |
|
Thread.sleep(SMALL_DELAY_MS); |
384 |
|
} |
385 |
< |
catch(Exception e) { |
385 |
> |
catch (Exception e) { |
386 |
|
threadUnexpectedException(); |
387 |
|
} |
388 |
|
lock.unlock(); |
394 |
|
assertTrue(lock.isLocked()); |
395 |
|
t.join(); |
396 |
|
assertFalse(lock.isLocked()); |
397 |
< |
} catch(Exception e){ |
397 |
> |
} catch (Exception e){ |
398 |
|
unexpectedException(); |
399 |
|
} |
400 |
|
} |
414 |
|
Thread.sleep(SHORT_DELAY_MS); |
415 |
|
lock.unlock(); |
416 |
|
t.join(); |
417 |
< |
} catch(Exception e){ |
417 |
> |
} catch (Exception e){ |
418 |
|
unexpectedException(); |
419 |
|
} |
420 |
|
} |
426 |
|
final ReentrantLock lock = new ReentrantLock(); |
427 |
|
try { |
428 |
|
lock.lockInterruptibly(); |
429 |
< |
} catch(Exception e) { |
429 |
> |
} catch (Exception e) { |
430 |
|
unexpectedException(); |
431 |
|
} |
432 |
|
Thread t = new Thread(new InterruptedLockRunnable(lock)); |
436 |
|
assertTrue(lock.isLocked()); |
437 |
|
assertTrue(lock.isHeldByCurrentThread()); |
438 |
|
t.join(); |
439 |
< |
} catch(Exception e){ |
439 |
> |
} catch (Exception e){ |
440 |
|
unexpectedException(); |
441 |
|
} |
442 |
|
} |
538 |
|
c.await(); |
539 |
|
lock.unlock(); |
540 |
|
} |
541 |
< |
catch(InterruptedException e) { |
541 |
> |
catch (InterruptedException e) { |
542 |
|
threadUnexpectedException(); |
543 |
|
} |
544 |
|
} |
714 |
|
c.await(); |
715 |
|
lock.unlock(); |
716 |
|
} |
717 |
< |
catch(InterruptedException e) { |
717 |
> |
catch (InterruptedException e) { |
718 |
|
threadUnexpectedException(); |
719 |
|
} |
720 |
|
} |
756 |
|
c.await(); |
757 |
|
lock.unlock(); |
758 |
|
} |
759 |
< |
catch(InterruptedException e) { |
759 |
> |
catch (InterruptedException e) { |
760 |
|
threadUnexpectedException(); |
761 |
|
} |
762 |
|
} |
771 |
|
c.await(); |
772 |
|
lock.unlock(); |
773 |
|
} |
774 |
< |
catch(InterruptedException e) { |
774 |
> |
catch (InterruptedException e) { |
775 |
|
threadUnexpectedException(); |
776 |
|
} |
777 |
|
} |
816 |
|
c.await(); |
817 |
|
lock.unlock(); |
818 |
|
} |
819 |
< |
catch(InterruptedException e) { |
819 |
> |
catch (InterruptedException e) { |
820 |
|
threadUnexpectedException(); |
821 |
|
} |
822 |
|
} |
830 |
|
c.await(); |
831 |
|
lock.unlock(); |
832 |
|
} |
833 |
< |
catch(InterruptedException e) { |
833 |
> |
catch (InterruptedException e) { |
834 |
|
threadUnexpectedException(); |
835 |
|
} |
836 |
|
} |
938 |
|
lock.unlock(); |
939 |
|
threadShouldThrow(); |
940 |
|
} |
941 |
< |
catch(InterruptedException success) { |
941 |
> |
catch (InterruptedException success) { |
942 |
|
} |
943 |
|
} |
944 |
|
}); |
969 |
|
lock.unlock(); |
970 |
|
threadShouldThrow(); |
971 |
|
} |
972 |
< |
catch(InterruptedException success) { |
972 |
> |
catch (InterruptedException success) { |
973 |
|
} |
974 |
|
} |
975 |
|
}); |
1001 |
|
lock.unlock(); |
1002 |
|
threadShouldThrow(); |
1003 |
|
} |
1004 |
< |
catch(InterruptedException success) { |
1004 |
> |
catch (InterruptedException success) { |
1005 |
|
} |
1006 |
|
} |
1007 |
|
}); |
1031 |
|
c.await(); |
1032 |
|
lock.unlock(); |
1033 |
|
} |
1034 |
< |
catch(InterruptedException e) { |
1034 |
> |
catch (InterruptedException e) { |
1035 |
|
threadUnexpectedException(); |
1036 |
|
} |
1037 |
|
} |
1044 |
|
c.await(); |
1045 |
|
lock.unlock(); |
1046 |
|
} |
1047 |
< |
catch(InterruptedException e) { |
1047 |
> |
catch (InterruptedException e) { |
1048 |
|
threadUnexpectedException(); |
1049 |
|
} |
1050 |
|
} |
1082 |
|
threadAssertEquals(1, lock.getHoldCount()); |
1083 |
|
lock.unlock(); |
1084 |
|
} |
1085 |
< |
catch(InterruptedException e) { |
1085 |
> |
catch (InterruptedException e) { |
1086 |
|
threadUnexpectedException(); |
1087 |
|
} |
1088 |
|
} |
1099 |
|
lock.unlock(); |
1100 |
|
lock.unlock(); |
1101 |
|
} |
1102 |
< |
catch(InterruptedException e) { |
1102 |
> |
catch (InterruptedException e) { |
1103 |
|
threadUnexpectedException(); |
1104 |
|
} |
1105 |
|
} |
1141 |
|
ReentrantLock r = (ReentrantLock) in.readObject(); |
1142 |
|
r.lock(); |
1143 |
|
r.unlock(); |
1144 |
< |
} catch(Exception e){ |
1144 |
> |
} catch (Exception e){ |
1145 |
|
e.printStackTrace(); |
1146 |
|
unexpectedException(); |
1147 |
|
} |