Sun bug activity related to Concurrency or Collections

(generated on 2008-03-14 12:33:32)

Open for JDK 6 Update
Open for JDK 5 Update
Fixed in JDK 7
Fixed in JDK 6 Update
Fixed in JDK 6
Fixed in JDK 5 Update
Fixed in JDK 5

Open bugs

101 bugs found.

java/hotspot/compiler2 (2 bugs: 2 Defects, 0 RFEs)

5014723 java/util/concurrent regression tests fail sporadically on multiprocessors
6533165 Failure to optimize methods that unconditionally throw

java/hotspot/garbage_collector (1 bug: 1 Defect, 0 RFEs)

6493335 Mismatch between -Xm[sx] and verbose:gc output

java/hotspot/runtime_system (3 bugs: 2 Defects, 1 RFE)

6313903 Thread.sleep(3) might wake up immediately on windows
6458294 nanoTime affected by system clock change on Linux (RH9) or in general lacks monotonicity
6561443 Timeout on synchronized blocks

java/java/classes_lang (3 bugs: 1 Defect, 2 RFEs)

6543593 (reflect) Clarify private final field mutability
4630118 (ref) Add joined weak references / weak properties
6558265 (thread) Using thread locals with thread pools may lead to unintentional object retention

java/java/classes_math (1 bug: 1 Defect, 0 RFEs)

6348370 java.math.BigInteger is *not* thread-safe immutable

java/java/classes_util (41 bugs: 11 Defects, 30 RFEs)

4200095 (coll) overstated wording regarding fail-fast behavior of iterators
5045147 (coll) Adding null to an empty TreeSet should throw NullPointerException
6312706 (coll) Map entrySet iterators should return different entries on each call to next()
6327883 (coll spec) Add @see newSetFromMap for Map implementations without Set implementations
6394757 (coll) AbstractSet.removeAll is surprisingly dependent on relative collection sizes
6420847 (coll) Clarify that serializable collections need serializable elements
6433005 (coll) Collection wrappers should implement Serializable iff wrapped collection does
6475385 (coll) modCount inconsistency / bad Collections.reverse implementation
6546713 (coll) Clarify meaning of "(optional)" in collections docs
6576056 (coll) AbstractSet/AbstractMap equals() method is asymmetric with large sets/maps
6579224 (coll) toString() on self-referential Checked collections causes stack overflow
4429536 (coll) WeakHashMap limitation: values refer to keys
4500542 (coll) WeakIdentityHashMap wanted
4848853 (coll) Modify LinkedHashMap and LinkedHashSet to include first() and last()
5029031 (coll) JDK1.5 The method Collections.checkedQueue(Queue<T>,Class) is missing
6189055 (timer) Add nanosecond support to java.util.Timer
6266354 (coll) LinkedHashMap to support ListIterators
6327463 (coll) Collections.synchronizedMap should return ConcurrentMap
6337998 (coll) AbstractList.equals() uses Iterator which has a large performance cost
6350345 Add filter class to java.util
6355410 Impossible for subclasses to preserve the equals contract
6356745 (coll) Add PriorityQueue(Collection, Comparator)
6363651 (coll) factory methods in collections classes to ease collection creation
6368844 (coll) Provide scalable double-ended lists
6371446 (coll) make Collections.SynchronizedCollection and etc. public
6386158 (coll) Provide collection class internal consistency validation methods
6389004 (coll) Collections.list should take Iterator, not just Enumeration
6392565 (coll) LinkedHashMap should contain single boolean constructor
6407460 (coll) provide Collections helper methods for new interfaces in JDK 1.6
6423502 (coll) Add value-weak version of WeakHashMap
6431610 (coll) util.Hashing class
6431636 (coll) New methods for handling iterable sequences in Collection framework
6435963 (coll) Hasher interface to be used by a HashMap/HashSet
6437680 (coll) Provide convenience methods to support array concatenation
6437681 (coll) Provide convenience methods to remove a subarray from an array
6438838 (coll) Add e, T... elements)
6461901 (coll) Add Collections.unmodifiableNavigableXXX, synchronizedNavigableXXX, checkedNavigableXXX
6463989 (coll) Provide Iterable utility methods and light-weight Iterable implementations
6471768 (coll) Checked Collections to implement interface to expose the checked type
6552529 (coll) Map.getEntry(key), Map.getKey(key)
6567419 (coll) Add MultiMap, MultiSet interfaces

java/java/classes_util_concurrent (48 bugs: 23 Defects, 25 RFEs)

6374942 Improve thread safety of collection .equals() methods
6443670 Javadoc for AtomicInteger ( missing information - get() v.s. intValue()
6458065 Executors.privilegedThreadFactory and privilegedCallable should specify permissions
6493942 ConcurrentLinkedQueue.remove sometimes very slow
6495521 API Javadoc of ConcurrentSkipListMap links to web page NOT describing SkipList
6512397 ConcurrentHashMap segment resize threshold improvement
6519887 Document whether "done" methods execute before waiters are released
6526284 Improve AbstractExecutorService javadoc
6531234 What if FutureTask.cancel throws?
6539720 PriorityBlockingQueue with ThreadPoolExecutor will cause ClassCastException
6593716 Serialized Form javadoc for LinkedBlockingDeque contradicts implementation
6595669 regtest LinkedBlockingQueue/ fails
6602600 Fast removal of cancelled scheduled thread pool tasks
6609775 Reduce context switches in DelayQueue due to signalAll
6620164 Clarify that BlockingQueue.drainTo() never blocks
6620549 ExecutorService#shutdown should clearly state that it does not block
6624849 test/java/util/concurrent/Exchanger/ fails
6625723 Excessive ThreadLocal storage used by ReentrantReadWriteLock
6627356 Try to preserve Lock invariants even when faced with Thread.stop
6633113 test/java/util/concurrent/SynchronousQueue/ fails intermittently
6633605 Optimize CopyOnWriteArrayList bulk operations on empty collections
6663476 FutureTask.get() may return null if set() is not called from run()
6665818 FutureTask bullet-proofing
6317534 CyclicBarrier should have a cancel() method
6350736 Future hasStarted() and waitForStart() methods
6350741 CyclicBarrier notification that barrier has been entered
6351533 CyclicBarrier reset() should return the number of awaiters
6358852 Add methods on concurrent data structures that interrupt blocked threads
6364794 Callable/Future interfaces awkward w.r.t. checked exceptions
6431628 Generics support in the concurrency package
6445151 Scalable counters
6445158 Clocks and improved CyclicBarriers
6445161 ConcurrentIdentityHashMap
6445163 TimeoutExecutor
6445165 implementation scalability improvements
6445167 Executor parallel collection operations
6445168 Software Transactional Memory
6448185 Consider adding StoreStore barriers to all constructor ends
6452337 ThreadPoolExecutor should prefer reusing idle threads
6486197 ConcurrentHashMap.get should check key identity before equality
6539709 There is no way to tell if an ExecutorService is idle
6552960 BlockingQueue implementations internal Lock protected, not private
6568991 WaitForMultipleObjects features in java.util.concurrent
6575582 ThreadPoolExecutor unusable in sandbox WebStart apps
6625724 Allow ReentrantReadWriteLock to not track per-thread read holds
6648211 Need for blocking ThreadPoolExecutor
6648734 Investigate importing features from the Prometheus Project
6673896 System ScheduledThreadPoolExecutor/Timer

java/java/other (1 bug: 0 Defects, 1 RFE)

4078860 API doc comments should describe the concurrency semantics of classes & methods

java/java/serialization (1 bug: 0 Defects, 1 RFE)

6379948 Need mechanism for implementing serializable classes with final fields

Open bugs targeted for Jdk 6 update

0 bugs found.

Open bugs targeted for Jdk 5 update

1 bug found.

java/java/classes_util_concurrent (1 bug: 1 Defect, 0 RFEs)

6576792 ThreadPoolExecutor methods leak interrupts when run in pool threads

Bugs fixed in Jdk 7

46 bugs found.

java/hotspot/compiler2 (1 bug: 1 Defect, 0 RFEs)

6500685 VM hangs after 'made not entrant java.util.concurrent.........'

java/java/classes_lang (1 bug: 1 Defect, 0 RFEs)

6519418 (spec) System.nanoTime() needs substantial clarification

java/java/classes_util (17 bugs: 15 Defects, 2 RFEs)

6437371 (coll) TreeMap.buildFromSorted midpoint calculation
6467933 (coll) TreeMap head/tailMap() methods handle null keys incorrectly
6487321 (timer) Timer spec should suggest use of ScheduledThreadPoolExecutor
6529795 (coll) Iterator.remove() fails if next() threw NoSuchElementException
6425537 (coll) WeakHashMap thread safety
6548425 Arrays.sort incorrectly sorts a double array containing negative zeros
6359979 (coll) Speed up collection iteration
6427291 (coll) Comparator should mention null parameter
6433170 (coll) CheckedCollection.addAll(Collection) breaks all-or-nothing semantic
6489956 (coll) AbstractQueue suggests iterator().remove() is non-optional
6519662 (coll) AbstractMap collection views should override clear and isEmpty
6533203 (coll) AbstractList.ListItr.add might corrupt iterator state if enclosing add throws
6533307 (coll) Optimize AbstractList range checking
6499848 (coll) WeakHashMap's HashIterator may skip entries
6409434 (coll) checked collections should consistently permit nulls
5103956 (coll) Suggested improvement to speed up ArrayList<E> get and set calls
5017904 (coll) Collections.emptyIterator, Collections.emptyEnumeration

java/java/classes_util_concurrent (27 bugs: 27 Defects, 0 RFEs)

6458306 Executor classes missing unchecked exception specs
6497138 Scalability limitation in ConcurrentHashMap on Java 6
6460501 Synchronizer timed acquire still leaks memory
6480405 Remove sun.misc.AtomicLong
6503247 AQS should not handle RuntimeException during acquire specially
6464365 FutureTask.{set,setException} not called by run()
6450200 ThreadPoolExecutor idling core threads don't terminate when core pool size reduced
6450205 ThreadPoolExecutor does not replace throwing threads
6450207 ThreadPoolExecutor doesn't count throwing tasks as "completed"
6450211 ThreadPoolExecutor.afterExecute sees RuntimeExceptions, but not Errors
6454289 ScheduledThreadPoolExecutor spins while waiting for delayed tasks after shutdown
6458339 ThreadPoolExecutor very slow to shut down for large poolSize
6458662 ThreadPoolExecutor poolSize might shrink below corePoolSize after timeout
6459119 Explain how afterExecute can access a submitted job's Throwable
6522773 Decreasing ScheduledThreadPoolExecutor core pool size causes busy spin
6523756 ThreadPoolExecutor shutdownNow vs execute race
6558708 Rewrite package.html as
6415572 FutureTask run method can swallow exceptions from done method
6560953 Periodic tasks of ScheduledThreadPoolExecutor are not decorated on a second run
6476650 Improve ReentrantReadWriteLock code sample
6570566 Incorrect range check in CopyOnWriteArrayList subLists
6570575 Cannot remove elements from CopyOnWriteArrayList subLists
6570631 CopyOnWriteArrayList subLists prohibit even non-structural modifications to parent list
6570924 CopyOnWriteArrayList subLists should implement RandomAccess
6576792 ThreadPoolExecutor methods leak interrupts when run in pool threads
6574123 Help implementers of fair synchronizers
6590649 Improve ExecutorCompletionService javadoc

Bugs fixed in Jdk 6 Update

5 bugs found.

java/java/classes_util (1 bug: 1 Defect, 0 RFEs)

6529795 (coll) Iterator.remove() fails if next() threw NoSuchElementException

java/java/classes_util_concurrent (4 bugs: 4 Defects, 0 RFEs)

6460501 Synchronizer timed acquire still leaks memory
6497138 Scalability limitation in ConcurrentHashMap on Java 6
6576792 ThreadPoolExecutor methods leak interrupts when run in pool threads
6639183 Scheduling large negative delay hangs entire ScheduledExecutor

Bugs fixed in Jdk 6

167 bugs found.

java/hotspot/compiler2 (2 bugs: 2 Defects, 0 RFEs)

6332491 Performance regression in b54 on x86
6454444 SEGV on solaris-i586 -server running ConcurrentQueueLoops

java/hotspot/runtime_system (1 bug: 1 Defect, 0 RFEs)

6317397 Hard hangs in concurrent code on Solaris and Linux

java/java/classes_lang (6 bugs: 6 Defects, 0 RFEs)

6184975 (thread spec) Clarify specification for ThreadLocal
4082705 (spec thread) interrupt signal issued before thread start is lost
6311092 (spec thread) InterruptedException usage doc should not say "if *another* thread has interrupted"
5069132 (spec) Runnable should have "see also" to Callable
6366835 (coll) Clarify Comparable.compareTo spec
4764778 Interrupted thread can't load classes from classes directory (sol)

java/java/classes_util (68 bugs: 57 Defects, 11 RFEs)

4825214 (coll) javadoc typo in
6244735 (coll spec) Minor SortedSet, SortedMap doc fixes
6258108 (coll) Improve Comparator, Comparable javadoc
4866451 (coll spec) Arrays.binarySearch() says list.size() when it should say a.length
5018268 (coll spec) "on a such a" typo in java.util.List and java.util.Map
6306826 (coll spec) Hashtable spec inaccuracy
4774490 (coll spec) Doc bug in Vector.writeObject(ObjectOutputStream)
6197726 (coll) IdentityHashMap.entrySet().toArray(T[] a) is incorrectly implemented
6310858 (coll) EnumMap.entrySet().toArray(T[] a) is incorrectly implemented
4991133 (coll spec) Typo in the readObject method of the java.util.PriorityQueue class
6186175 (coll spec) Redundant method mention in AbstractList documentation
5103030 (coll spec) Doc comment out of sync with generified Collection.toArray()
4838705 (coll spec) Bug in "toArray" example for Interface "Collection"
4964029 (coll spec) Documentation for ArrayList.removeRange() doesn't mention Exceptions
4521038 (coll spec) Clarify that ArrayList.contains uses "equals"
4802637 (coll) Minor change to TreeMap.getEntry comparison code for performance
4904074 (coll) Provide basic Map.Entry class
5018254 (coll) 'remove' operation fails in tailMap of a null-key-allowing TreeMap
5018849 (coll) TreeSet.contains(null) does not agree with Javadoc
6207984 (coll) PriorityQueue.remove(Object o) will remove an object with the same priority as o
6245166 (coll spec) TreeMap class documentation should use SortedMap instead of Map
6261984 (coll spec) *List collections doc fixes
6264242 (coll spec) foo(E o) -> foo(E e)
6268068 (coll) PriorityQueue.remove(Object) should use equals, not its ordering, to find element to remove
6269713 (coll) Unchecked exception specifications of collection classes are missing or inaccurate
6269720 (coll spec) Improve documentation of "natural ordering"
6271387 (coll spec) toArray method javadocs are inaccurate
6318553 (coll) Arrays.asList maintenance
6282555 (coll) Collection toString method optimizations
6318622 (coll spec) Collection toString method doc maintenance
6306829 (coll spec) Map get(Object) method doc maintenance
6318636 (coll) Collection putAll method maintenance
6325410 (coll spec) typo in Map specification
4229892 (coll spec) Arrays.fill(Object[], ...) should document ArrayStoreException
4936876 (coll spec) Vector.copyInto should document ArrayStoreException
6330389 (coll spec) SimpleEntry should inherit Map.Entry equals, hashCode spec
6331577 (coll spec) Gently denigrate Stack in favor of Deque
6331578 (coll spec) Disclaim any guarantees in case of concurrent access
4924316 java.util.Random spec problem on synchronization
6355099 (coll) PriorityQueue.grow resizes internal array by 4, not 2
6355660 (coll) Vector(Collection) constructor is not thread safe
6360008 (coll spec) Collections.addAll confusion over name of formal parameter "a" vs "elements"
6365601 (coll) asLifoQueue(...).add(E) should delegate to addFirst, not offerFirst
4974878 (coll) Collections and reverse order comparator
6366832 (coll) Collections.reverseOrder(null) should return Collections.REVERSE_ORDER
4890211 (coll) Collections.ReverseOrder.equals method is lacking
6369494 (timer) Timer.TaskQueue is susceptible to ArrayIndexOutOfBounds after OutOfMemoryError
6372554 (coll) Collections.ReverseComparator should override readResolve()
6379897 Random is not thread-safe; seed should be final
6347106 (coll) Make ArrayList(Collection) more threadsafe
6360946 (coll) SetFromMap.equals should perform identity check
6360948 (coll) Collections.newSetFromMap, asLifoQueue should delegate toString to wrapped collection
6370431 (coll) PriorityQueue.fixUp() use >> instead of >>>
6394004 (coll) Thread-safety and Performance improvements to PriorityQueue
6396914 (coll) Clarify all asLifoQueue(deq) operations except addAll map 1-1
6242436 (coll) TreeMap.SubMap doesn't deserialize properly
6421995 (coll) Minor doc fixes
6301089 (coll) Add Collections.newSetFromMap(Map<E,Boolean>)
4137464 (coll) TreeMap should have bi-directional iterator
4155650 (coll) Sorted Collection Classes with bidirectional navigation
4216399 (coll) TreeMap: please make getCeilEntry and getPreviousEntry >>public<<
4294891 (coll) Add "next/previous" to both SortedMap and SortedSet
4942830 (coll spec) TreeSet.remove - absence of Compara{ble,tor} throws ClassCastException
5048399 (coll) please fix anachronisms in collections internal generification
6301085 (coll) Add Collections.asLifoQueue(Deque)
6324846 (coll) Add Deque.descendingIterator()
4261170 (spec) Precisely specify bytes generated by Random.nextBytes
6415641 (coll) Getting NavigableMap/NavigableSet right

java/java/classes_util_concurrent (89 bugs: 79 Defects, 10 RFEs)

6189072 Add sometimes fails after clear or drainTo in LinkedBlockingQueue
6226308 (spec) Semaphore example code contains incorrect field declaration
6233035 Clarify Queue and BlockingQueue javadocs by adding tables showing relations among methods
6241823 Infinite loop in timed Semaphore.tryAcquire
6253848 CyclicBarrier behavior incorrect if "broken" or reset
6256764 java.util.concurrent.atomic doc fixes
6301119 java.util.concurrent.atomic maintenance
6307455 LinkedBlockingQueue.toArray(x) does not set "one-past" element of x to null
6306762 java.util.concurrent.locks maintenance
6299797 FutureTask.get should document @throws CancellationException
6284408 Clarify that FutureTask set methods are invoked automatically by run()
6280606 Clarify Executors.newFixedThreadPool spec
5017565 Executors.defaultThreadFactory doc should mention MaxPriority
5075597 Incomplete javadoc for ScheduledExecutorService.scheduleAtFixedRate()
6179024 Clarify what happens if await timeout set to 0
6309755 Clarify "happens-before" relationships
6270647 CopyOnWriteArrayList.listIterator erroneously refers to Enumeration methods
6264520 DelayQueue confuses "expired" and "unexpired"
6284402 Clarify which DelayQueue methods can "see" unexpired elements
6215625 LinkedBlockingQueue.extract throws NPE
6267833 Incorrect method signature ExecutorService.invokeAll()
5073546 Minor ConcurrentHashMap constructor spec tweaks
5108057 Small Error in JavaDoc for method isEmpty of ConcurrentLinkedQueue
6192476 CopyOnWriteArraySet.iterator should explicitly say it uses list order
6233236 Reduce need to replace interrupted worker threads in ThreadPoolExecutor for performance
6236036 Timeouts can cause garbage retention in lock classes
6247907 Interruptions and ThreadPoolExecutor.runTask
6264015 Performance improvement to Exchanger and SynchronousQueue
6269146 Cancelled FutureTask's interrupt bit not always set
6269729 Improve method tables in BlockingDeque and related interfaces
6269739 BlockingQueue.drainTo needs to throw all unchecked exceptions that Collection.add does
6269785 ConcurrentMap.replace,remove methods "equivalent" code not correct when elt not in map
6281487 ReentrantReadWriteLock: readers repeatedly acquire lock while writer is waiting
6282140 CopyOnWriteArrayList maintenance
6294770 java.util.concurrent.locks.ReentrantReadWriteLock acquisition order
6305337 Reentrant writeLock in Fair mode ReentrantReadWriteLock may block
6312056 ConcurrentHashMap.entrySet().iterator() can return entry with never-existent value
6314788 Tasks resubmitted to a ThreadPoolExecutor may fail to execute
6315709 Reentrant writeLock in Fair mode ReentrantReadWriteLock may block
6272521 ConcurrentHashMap.remove(x,null) might remove x
6316155 LinkedBlockingQueue: q.offer(xyz) returns false positives and/or q.remove(xyz) gives up too easily
6320744 CopyOnWriteArrayList.clone should call resetLock
6318638 race condition in CopyOnWriteArrayList.equals
6322334 Atomics should use Unsafe lazy field set methods
6322396 CopyOnWriteArrayList.set(int, E) should always have volatile write semantics
6322999 Clarify memory and atomicity guarantees of atomic field updaters
6320761 Add more "happens-before" clarifications
6324857 Clarify that Exchanger allows threads to "pair up"
6327342 DelayQueue.poll(timeout, unit) can spin past given timeout
6332435 Add regression test for CountDownLatch
6330307 Improve CopyOnWriteArraySet, CopyOnWriteArrayList equals method
6345077 Javadoc for ConcurrentLinkedQueue is deficient
6347144 Exchanger maintenance
6355645 CopyOnWriteArrayList bulk operations have race conditions
6366811 CyclicBarrier behaviour incorrect if interruption occurs during barrier "trip"
6355327 Concurrent collection iterators should not throw ConcurrentModificationException
6363898 Excise vestigial "int index" field of TimeUnit
6362121 ClassCastException in ScheduledFutureTask.compareTo
6373383 Revert AtomicReference.compareAndSet to tiger version
6383475 ConcurrentSkipListMap.remove(null,null) will not throw NullPointerException
6384064 SynchronousQueue put/take interrupt handling differs from timed poll
6361785 Spin control in Exchanger
6384622 may hang
6373953 Future.cancel doc "has" small grammar problem
6402327 Clarify Condition.awaitNanos negative return value ambiguity
6402333 LockSupport.park guidance
6398290 Exception specifications in ScheduledThreadPoolExecutor/Executors
6399443 ThreadPoolExecutor leak
6404123 @link => @linkplain and other minor doc fixes
6416543 Small improvements to regtest CancelledProducerConsumerLoops
6377302 AbstractCollection.toArray is not safe for concurrent collections
6431315 ThreadPoolExecutor.shutdownNow may hang ExecutorService.invokeAll
6431845 Bug in serialization of ArrayBlockingQueue
6435792 javadoc is wrong for ThreadPoolExecutor.setMaximumPoolSize(int)
6425639 Clarify weakCompareAndSet doc
6440728 ThreadPoolExecutor can fail to execute successfully submitted tasks as specified
6443125 Clarify that ThreadFactory.newThread can return null
6449110 Improve shutdown documentation for ExecutorService
6448274 ThreadPoolExecutor.getTaskCount should abandon monotonicity guarantee
6275329 Add lazySet methods to atomic classes
5057341 TimeUnit needs additional Enums for longer durations
6237968 Add AbstractQueuedLongSynchronizer, providing support for 64 bits of synchronization state
6268386 jsr166x -- collections and concurrency maintenance update
6192552 Deques
6207928 ReentrantReadWriteLock provides no way to tell if current thread holds read lock
6233235 Add allowCoreThreadTimeOut to ThreadPoolExecutor to optionally allow core thread to use keep-alive
6277663 Improve extensibility of thread pools
6281377 Provide Unsafe lazy field set methods
6378321 More methods for ReentrantReadWriteLock.WriteLock

java/java/other (1 bug: 1 Defect, 0 RFEs)

6364793 Add missing @since 1.6 in Core Library javadoc

Bugs fixed in Jdk 5 update

13 bugs found.

java/hotspot/compiler2 (1 bug: 1 Defect, 0 RFEs)

6454444 SEGV on solaris-i586 -server running ConcurrentQueueLoops

java/hotspot/runtime_system (1 bug: 1 Defect, 0 RFEs)

6317397 Hard hangs in concurrent code on Solaris and Linux

java/java/classes_util (2 bugs: 2 Defects, 0 RFEs)

6197726 (coll) IdentityHashMap.entrySet().toArray(T[] a) is incorrectly implemented
6310858 (coll) EnumMap.entrySet().toArray(T[] a) is incorrectly implemented

java/java/classes_util_concurrent (9 bugs: 9 Defects, 0 RFEs)

6189072 Add sometimes fails after clear or drainTo in LinkedBlockingQueue
6241823 Infinite loop in timed Semaphore.tryAcquire
6253848 CyclicBarrier behavior incorrect if "broken" or reset
6307455 LinkedBlockingQueue.toArray(x) does not set "one-past" element of x to null
6215625 LinkedBlockingQueue.extract throws NPE
6327342 DelayQueue.poll(timeout, unit) can spin past given timeout
6366811 CyclicBarrier behaviour incorrect if interruption occurs during barrier "trip"
6460501 Synchronizer timed acquire still leaks memory
6470111 Deadlock in Exchanger

Bugs fixed in Jdk 5

46 bugs found.

java/hotspot/compiler2 (1 bug: 1 Defect, 0 RFEs)

5063575 VM crashes or incorrect behavior on uniprocessor Solaris/Linux machines

java/hotspot/jvm_interface (1 bug: 1 Defect, 0 RFEs)

4986284 Unsafe_CompareAndSwapLong requires an 8-byte hardware CAS instruction

java/hotspot/runtime_system (1 bug: 1 Defect, 0 RFEs)

4986764 (thread) Thread.setUncaughtExceptionHandler doesn't work

java/java/classes_lang (9 bugs: 8 Defects, 1 RFE)

4919105 (thread) generify Thread.getAllStackTraces()
4955958 (thread) ThreadLocal.ThreadLocalMap should not be generic
4617307 (thread) Thread spec doesn't document that threads can't be restarted
4267567 (thread) Thread.destroy should be deprecated
4931928 (thread) generify InheritableThreadLocal
5010743 (thread spec) stop(Throwable) has an @link to itself; should be stop()
5063815 Stray "{" in ThreadGroup doc
4960148 (thread) Thread.destroy method is not implemented
4877110 (spec thread) Thread.activeCount spec is ambiguous

java/java/classes_util (2 bugs: 1 Defect, 1 RFE)

4973432 toString behavior on IdentityHashMap.entrySet() element could be improved
4949279 no-arg Random constructor should use nanoTime for seed.

java/java/classes_util_concurrent (30 bugs: 30 Defects, 0 RFEs)

4929370 Bring JSR-166 up to date with Public Draft
4934165 RegTest-test java/util/concurrent/BlockingQueue/CancelledProducerConsumerLoops.j
4939930 Bring JSR-166 up to date with Public Review Nov 2003
4943320 Regression-test java/util/concurrent/FutureTask/ fails
4945773 Regression-test java/util/concurrent/locks/ReentrantLock/CancelledLockLoops
4965960 Bring JSR-166 up to date with Public Review Jan 2004
4992196 ReentrantReadWriteLock defines serializable inner classes
4994250 Very minor JSR-166 documentation fixes
4997482 ScheduledThreadPoolExecutor.remove(Runnable) should not throw an exception
4996165 (spec) weakCompareAndSet has different memory effects from compareAndSet
4992438 SynchronousQueue does not expose fairness properties
4992443 AtomicLongFieldUpdater.CompareAndSwap locks wrong lock on old platforms
5022665 "&" should be "&&"
5028262 raw types in java.util.concurrent
5030010 ConcurrentHashMap does not conform to JSR133 spec
5031862 Fix TimeoutLockLoops to no longer trigger sporadic failures (see 5014723)
5030012 ThreadPoolExecutor can fail if ThreadFactory.newThread does
5032617 FutureTask.cancel can fail to cancel
5030013 Misc documentation fixes from JSR-166 public review
5055158 DelayQueue take(), poll() and poll(long delay, TimeUnit tu) are flawed
5055732 CopyOnWriteArraySet does not define a public clone method
5062327 Clarify checks performed by ThreadPoolExecutor.shutdown()
5059659 Clarify the thread safety of BlockingQueue
5056023 Some BlockingQueue inherited implementation method docs are incorrect
5055213 Clarify that it is the collection class' iterators which implements Iterator
5057608 java.util.concurrent.ArrayBlockingQueue doc conflict
5067025 ConcurrentHashMap's keySet, values toArray can throw IndexOutOfBoundsException
5068269 Miscellaneous JSR-166 documentation improvements
5058273 java.util.concurrent.AtomicBoolean.compareAndSet doc conflict
5071296 Clarify and fix ReentrantReadWriteLock

java/java/tools (2 bugs: 2 Defects, 0 RFEs)

4992454 (thread) setUncaughtExceptionHandler() doesn't work on main thread
4833089 (thread) If main thread dies from unhandled exception, isAlive() is still true

Recently resolved (but not fixed) bugs

24 bugs found.

java/hotspot/compiler1 (1 bug: 1 Defect, 0 RFEs)

6573847 JVM 1.6 crash on java.util.concurrent.LinkedBlockingQueue$Itr.remove()

java/hotspot/garbage_collector (1 bug: 1 Defect, 0 RFEs)

6493287 Unproductive CPU-spinning GCs on heap exhaustion; please throw OOME instead

java/hotspot/runtime_system (2 bugs: 1 Defect, 1 RFE)

6447639 Faulty implementation of JSR166 - LockSupport
6440250 On Windows System.nanoTime() may be 25x slower than System.currentTimeMillis()

java/java/classes_lang (3 bugs: 2 Defects, 1 RFE)

6480016 System.nanoTime() results vary between Java SE 6.0 and 5.0
6307490 (spec thread) Thread.State or related doc should clarify valid notifyAll() behavior
4291382 Object.{wait,notify}() should support a new QUEUE/CONDITION parameter

java/java/classes_util (10 bugs: 7 Defects, 3 RFEs)

6423457 (coll) High cpu usage in HashMap.get()
6307475 (coll) Optimize AbstractCollection.toArray()
6385838 (coll) TreeSet.addAll() may create improperly sorted set
6495524 (coll) PriorityQueue.poll() throws NullPointerException
6467933 (coll) TreeMap head/tailMap() methods handle null keys incorrectly
6530901 (coll) TreeMap.firstKey() violates NavigableMap contract when map empty
6336543 (timer) TimerThread.mainLoop shouldn't ignore InterruptedException for non-daemon Timer threads
4912961 (coll) The set returned by TreeMap.keySet should implement SortedSet
6431617 (coll) AbstractList$Itr is not serializable
6479352 (timer) Timer to accept a context classloader for the thread it creates

java/java/classes_util_concurrent (7 bugs: 5 Defects, 2 RFEs)

6294770 java.util.concurrent.locks.ReentrantReadWriteLock acquisition order
6450705 NullPointerException in LinkedBlockingQueue.peek
6236036 Timeouts can cause garbage retention in lock classes
6480405 Remove sun.misc.AtomicLong
6316155 LinkedBlockingQueue: q.offer(xyz) returns false positives and/or q.remove(xyz) gives up too easily
4894657 Add multiple-reader/single-writer synchronization
6653412 Need blocking version of peek() in BlockingQueue implementations


Closed (not fixed)