Index: src/test/java/SynchronousQueueTest.java =================================================================== --- src/test/java/SynchronousQueueTest.java (revision 488945) +++ src/test/java/SynchronousQueueTest.java (working copy) @@ -154,7 +154,7 @@ } /** - * put blocks interruptibly if no active taker + * put blocks interruptedly if no active taker */ public void testBlockingPut() { Thread t = new Thread(new Runnable() { @@ -240,7 +240,7 @@ /** - * take blocks interruptibly when empty + * take blocks interruptedly when empty */ public void testTakeFromEmpty() { final SynchronousQueue q = new SynchronousQueue(); @@ -264,7 +264,7 @@ /** - * put blocks interruptibly if no active taker + * put blocks interruptedly if no active taker */ public void testFairBlockingPut() { Thread t = new Thread(new Runnable() { @@ -350,7 +350,7 @@ /** - * take blocks interruptibly when empty + * take blocks interruptedly when empty */ public void testFairTakeFromEmpty() { final SynchronousQueue q = new SynchronousQueue(true); Index: src/test/java/ReentrantLockTest.java =================================================================== --- src/test/java/ReentrantLockTest.java (revision 488945) +++ src/test/java/ReentrantLockTest.java (working copy) @@ -866,15 +866,15 @@ /** - * awaitUninterruptibly doesn't abort on interrupt + * awaitUninterruptedly doesn't abort on interrupt */ - public void testAwaitUninterruptibly() { + public void testAwaitUninterruptedly() { final ReentrantLock lock = new ReentrantLock(); final Condition c = lock.newCondition(); Thread t = new Thread(new Runnable() { public void run() { lock.lock(); - c.awaitUninterruptibly(); + c.awaitUninterruptedly(); lock.unlock(); } }); Index: src/test/java/LinkedBlockingQueueTest.java =================================================================== --- src/test/java/LinkedBlockingQueueTest.java (revision 488945) +++ src/test/java/LinkedBlockingQueueTest.java (working copy) @@ -305,7 +305,7 @@ } /** - * put blocks interruptibly if full + * put blocks interruptedly if full */ public void testBlockingPut() { Thread t = new Thread(new Runnable() { @@ -410,7 +410,7 @@ } /** - * take blocks interruptibly when empty + * take blocks interruptedly when empty */ public void testTakeFromEmpty() { final LinkedBlockingQueue q = new LinkedBlockingQueue(2); @@ -433,7 +433,7 @@ } /** - * Take removes existing elements until empty, then blocks interruptibly + * Take removes existing elements until empty, then blocks interruptedly */ public void testBlockingTake() { Thread t = new Thread(new Runnable() { Index: src/test/java/AbstractQueuedSynchronizerTest.java =================================================================== --- src/test/java/AbstractQueuedSynchronizerTest.java (revision 488945) +++ src/test/java/AbstractQueuedSynchronizerTest.java (working copy) @@ -930,15 +930,15 @@ /** - * awaitUninterruptibly doesn't abort on interrupt + * awaitUninterruptedly doesn't abort on interrupt */ - public void testAwaitUninterruptibly() { + public void testAwaitUninterruptedly() { final Mutex sync = new Mutex(); final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); Thread t = new Thread(new Runnable() { public void run() { sync.acquire(1); - c.awaitUninterruptibly(); + c.awaitUninterruptedly(); sync.release(1); } }); Index: src/test/java/PriorityBlockingQueueTest.java =================================================================== --- src/test/java/PriorityBlockingQueueTest.java (revision 488945) +++ src/test/java/PriorityBlockingQueueTest.java (working copy) @@ -400,7 +400,7 @@ } /** - * take blocks interruptibly when empty + * take blocks interruptedly when empty */ public void testTakeFromEmpty() { final PriorityBlockingQueue q = new PriorityBlockingQueue(2); @@ -423,7 +423,7 @@ } /** - * Take removes existing elements until empty, then blocks interruptibly + * Take removes existing elements until empty, then blocks interruptedly */ public void testBlockingTake() { Thread t = new Thread(new Runnable() { Index: src/test/java/LinkedListTest.java =================================================================== --- src/test/java/LinkedListTest.java (revision 488945) +++ src/test/java/LinkedListTest.java (working copy) @@ -368,7 +368,7 @@ } /** - * toArray with incompatable aray type throws CCE + * toArray with incompatible array type throws CCE */ public void testToArray1_BadArg() { try { Index: src/test/java/DelayQueueTest.java =================================================================== --- src/test/java/DelayQueueTest.java (revision 488945) +++ src/test/java/DelayQueueTest.java (working copy) @@ -204,7 +204,7 @@ } /** - * remainingCapacity does not change when elementa added or removed, + * remainingCapacity does not change when elements added or removed, * but size does */ public void testRemainingCapacity() { @@ -438,7 +438,7 @@ } /** - * take blocks interruptibly when empty + * take blocks interruptedly when empty */ public void testTakeFromEmpty() { final DelayQueue q = new DelayQueue(); @@ -461,7 +461,7 @@ } /** - * Take removes existing elements until empty, then blocks interruptibly + * Take removes existing elements until empty, then blocks interruptedly */ public void testBlockingTake() { Thread t = new Thread(new Runnable() { Index: src/test/java/CopyOnWriteArrayListTest.java =================================================================== --- src/test/java/CopyOnWriteArrayListTest.java (revision 488945) +++ src/test/java/CopyOnWriteArrayListTest.java (working copy) @@ -596,7 +596,7 @@ } /** - * a deserialized serialiszed list is equal + * a deserialized serialized list is equal */ public void testSerialization() { CopyOnWriteArrayList q = populatedArray(SIZE); Index: src/test/java/ExecutorsTest.java =================================================================== --- src/test/java/ExecutorsTest.java (revision 488945) +++ src/test/java/ExecutorsTest.java (working copy) @@ -526,7 +526,7 @@ checkCCL(); return null; }}, noprivAcc); - // too many permssions; skip test + // too many permissions; skip test return; } catch(AccessControlException ok) { } Index: src/test/java/ReentrantReadWriteLockTest.java =================================================================== --- src/test/java/ReentrantReadWriteLockTest.java (revision 488945) +++ src/test/java/ReentrantReadWriteLockTest.java (working copy) @@ -650,15 +650,15 @@ } /** - * awaitUninterruptibly doesn't abort on interrupt + * awaitUninterruptedly doesn't abort on interrupt */ - public void testAwaitUninterruptibly() { + public void testAwaitUninterruptedly() { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); final Condition c = lock.writeLock().newCondition(); Thread t = new Thread(new Runnable() { public void run() { lock.writeLock().lock(); - c.awaitUninterruptibly(); + c.awaitUninterruptedly(); lock.writeLock().unlock(); } }); Index: src/test/java/SemaphoreTest.java =================================================================== --- src/test/java/SemaphoreTest.java (revision 488945) +++ src/test/java/SemaphoreTest.java (working copy) @@ -129,18 +129,18 @@ * Uninterruptible acquire and release of semaphore succeed if * initially available */ - public void testAcquireUninterruptiblyReleaseInSameThread() { + public void testAcquireUninterruptedlyReleaseInSameThread() { Semaphore s = new Semaphore(1, false); try { - s.acquireUninterruptibly(); + s.acquireUninterruptedly(); s.release(); - s.acquireUninterruptibly(); + s.acquireUninterruptedly(); s.release(); - s.acquireUninterruptibly(); + s.acquireUninterruptedly(); s.release(); - s.acquireUninterruptibly(); + s.acquireUninterruptedly(); s.release(); - s.acquireUninterruptibly(); + s.acquireUninterruptedly(); s.release(); assertEquals(1, s.availablePermits()); } finally { @@ -208,10 +208,10 @@ final Semaphore s = new Semaphore(0, false); Thread t = new Thread(new Runnable() { public void run() { - s.acquireUninterruptibly(); + s.acquireUninterruptedly(); s.release(); s.release(); - s.acquireUninterruptibly(); + s.acquireUninterruptedly(); } }); try { @@ -219,8 +219,8 @@ Thread.sleep(SHORT_DELAY_MS); s.release(); s.release(); - s.acquireUninterruptibly(); - s.acquireUninterruptibly(); + s.acquireUninterruptedly(); + s.acquireUninterruptedly(); s.release(); t.join(); } catch( InterruptedException e){ @@ -261,7 +261,7 @@ } /** - * A waiting acquire blocks interruptibly + * A waiting acquire blocks interruptedly */ public void testAcquire_InterruptedException() { final Semaphore s = new Semaphore(0, false); @@ -284,7 +284,7 @@ } /** - * A waiting timed acquire blocks interruptibly + * A waiting timed acquire blocks interruptedly */ public void testTryAcquire_InterruptedException() { final Semaphore s = new Semaphore(0, false); @@ -316,7 +316,7 @@ Thread t2 = new Thread(new InterruptibleLockRunnable(lock)); try { assertFalse(lock.hasQueuedThreads()); - lock.acquireUninterruptibly(); + lock.acquireUninterruptedly(); t1.start(); Thread.sleep(SHORT_DELAY_MS); assertTrue(lock.hasQueuedThreads()); @@ -345,7 +345,7 @@ Thread t2 = new Thread(new InterruptibleLockRunnable(lock)); try { assertEquals(0, lock.getQueueLength()); - lock.acquireUninterruptibly(); + lock.acquireUninterruptedly(); t1.start(); Thread.sleep(SHORT_DELAY_MS); assertEquals(1, lock.getQueueLength()); @@ -374,7 +374,7 @@ Thread t2 = new Thread(new InterruptibleLockRunnable(lock)); try { assertTrue(lock.getQueuedThreads().isEmpty()); - lock.acquireUninterruptibly(); + lock.acquireUninterruptedly(); assertTrue(lock.getQueuedThreads().isEmpty()); t1.start(); Thread.sleep(SHORT_DELAY_MS); @@ -532,19 +532,19 @@ /** * Acquire(n) and release(n) of semaphore succeed if initially available */ - public void testAcquireUninterruptiblyReleaseNInSameThread_fair() { + public void testAcquireUninterruptedlyReleaseNInSameThread_fair() { Semaphore s = new Semaphore(1, true); try { s.release(1); - s.acquireUninterruptibly(1); + s.acquireUninterruptedly(1); s.release(2); - s.acquireUninterruptibly(2); + s.acquireUninterruptedly(2); s.release(3); - s.acquireUninterruptibly(3); + s.acquireUninterruptedly(3); s.release(4); - s.acquireUninterruptibly(4); + s.acquireUninterruptedly(4); s.release(5); - s.acquireUninterruptibly(5); + s.acquireUninterruptedly(5); assertEquals(1, s.availablePermits()); } finally { } @@ -750,7 +750,7 @@ } /** - * A waiting acquire blocks interruptibly + * A waiting acquire blocks interruptedly */ public void testAcquire_InterruptedException_fair() { final Semaphore s = new Semaphore(0, true); @@ -773,7 +773,7 @@ } /** - * A waiting acquire(n) blocks interruptibly + * A waiting acquire(n) blocks interruptedly */ public void testAcquireN_InterruptedException_fair() { final Semaphore s = new Semaphore(2, true); @@ -796,7 +796,7 @@ } /** - * A waiting tryAcquire blocks interruptibly + * A waiting tryAcquire blocks interruptedly */ public void testTryAcquire_InterruptedException_fair() { final Semaphore s = new Semaphore(0, true); @@ -820,7 +820,7 @@ } /** - * A waiting tryAcquire(n) blocks interruptibly + * A waiting tryAcquire(n) blocks interruptedly */ public void testTryAcquireN_InterruptedException_fair() { final Semaphore s = new Semaphore(1, true); @@ -852,7 +852,7 @@ Thread t2 = new Thread(new InterruptibleLockRunnable(lock)); try { assertEquals(0, lock.getQueueLength()); - lock.acquireUninterruptibly(); + lock.acquireUninterruptedly(); t1.start(); Thread.sleep(SHORT_DELAY_MS); assertEquals(1, lock.getQueueLength()); Index: src/test/java/ArrayBlockingQueueTest.java =================================================================== --- src/test/java/ArrayBlockingQueueTest.java (revision 488945) +++ src/test/java/ArrayBlockingQueueTest.java (working copy) @@ -316,7 +316,7 @@ } /** - * put blocks interruptibly if full + * put blocks interruptedly if full */ public void testBlockingPut() { final ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE); @@ -421,7 +421,7 @@ } /** - * take blocks interruptibly when empty + * take blocks interruptedly when empty */ public void testTakeFromEmpty() { final ArrayBlockingQueue q = new ArrayBlockingQueue(2); @@ -444,7 +444,7 @@ } /** - * Take removes existing elements until empty, then blocks interruptibly + * Take removes existing elements until empty, then blocks interruptedly */ public void testBlockingTake() { Thread t = new Thread(new Runnable() { Index: src/main/java/java/util/concurrent/ExecutorService.java =================================================================== --- src/main/java/java/util/concurrent/ExecutorService.java (revision 488945) +++ src/main/java/java/util/concurrent/ExecutorService.java (working copy) @@ -225,7 +225,7 @@ * @return A list of Futures representing the tasks, in the same * sequential order as produced by the iterator for the given * task list. If the operation did not time out, each task will - * have completed. If it did time out, some of thiese tasks will + * have completed. If it did time out, some of these tasks will * not have completed. * @throws InterruptedException if interrupted while waiting, in * which case unfinished tasks are cancelled. Index: src/main/java/java/util/concurrent/ConcurrentHashMap.java =================================================================== --- src/main/java/java/util/concurrent/ConcurrentHashMap.java (revision 488945) +++ src/main/java/java/util/concurrent/ConcurrentHashMap.java (working copy) @@ -88,7 +88,7 @@ /** * The maximum capacity, used if a higher value is implicitly * specified by either of the constructors with arguments. MUST - * be a power of two <= 1<<30 to ensure that entries are indexible + * be a power of two <= 1<<30 to ensure that entries are indexable * using ints. */ static final int MAXIMUM_CAPACITY = 1 << 30; Index: src/main/java/java/util/concurrent/locks/ReentrantReadWriteLock.java =================================================================== --- src/main/java/java/util/concurrent/locks/ReentrantReadWriteLock.java (revision 488945) +++ src/main/java/java/util/concurrent/locks/ReentrantReadWriteLock.java (working copy) @@ -1100,7 +1100,7 @@ /** * Returns a string identifying this lock, as well as its lock state. * The state, in brackets, includes the String "Write locks =" - * follwed by the number of reentrantly held write locks, and the + * followed by the number of reentrantly held write locks, and the * String "Read locks =" followed by the number of held * read locks. * @return a string identifying this lock, as well as its lock state. Index: src/main/java/java/util/concurrent/locks/Condition.java =================================================================== --- src/main/java/java/util/concurrent/locks/Condition.java (revision 488945) +++ src/main/java/java/util/concurrent/locks/Condition.java (working copy) @@ -232,7 +232,7 @@ * implementation must document that fact. * **/ - void awaitUninterruptibly(); + void awaitUninterruptedly(); /** * Causes the current thread to wait until it is signalled or interrupted, Index: src/main/java/java/util/concurrent/locks/AbstractQueuedSynchronizer.java =================================================================== --- src/main/java/java/util/concurrent/locks/AbstractQueuedSynchronizer.java (revision 488945) +++ src/main/java/java/util/concurrent/locks/AbstractQueuedSynchronizer.java (working copy) @@ -283,7 +283,7 @@ * *

Insertion into a CLH queue requires only a single atomic * operation on "tail", so there is a simple atomic point of - * demarcation from unqueued to queued. Similarly, dequeing + * demarcation from unqueued to queued. Similarly, dequeuing * involves only updating the "head". However, it takes a bit * more work for nodes to determine who their successors are, * in part to deal with possible cancellation due to timeouts @@ -377,7 +377,7 @@ /** * Link to predecessor node that current node/thread relies on - * for checking waitStatus. Assigned during enqueing, and nulled + * for checking waitStatus. Assigned during enqueuing, and nulled * out (for sake of GC) only upon dequeuing. Also, upon * cancellation of a predecessor, we short-circuit while * finding a non-cancelled one, which will always exist @@ -1699,7 +1699,7 @@ * {@link #acquire} with saved state as argument. * */ - public final void awaitUninterruptibly() { + public final void awaitUninterruptedly() { Node node = addConditionWaiter(); int savedState = fullyRelease(node); boolean interrupted = false; Index: src/main/java/java/util/concurrent/Semaphore.java =================================================================== --- src/main/java/java/util/concurrent/Semaphore.java (revision 488945) +++ src/main/java/java/util/concurrent/Semaphore.java (working copy) @@ -286,7 +286,7 @@ * thread does return from this method its interrupt status will be set. * */ - public void acquireUninterruptibly() { + public void acquireUninterruptedly() { sync.acquireShared(1); } @@ -447,7 +447,7 @@ * @throws IllegalArgumentException if permits less than zero. * */ - public void acquireUninterruptibly(int permits) { + public void acquireUninterruptedly(int permits) { if (permits < 0) throw new IllegalArgumentException(); sync.acquireShared(permits); }