Achieve Strong Performance With Threads, Part 1
Gives an introduction to threads and explores the Thread class and runnables. |
Achieve Strong Performance With Threads, Part 3
Explains how priority relates to thread scheduling and how to use the wait/notify mechanism to coordinate the activities of multiple threads. |
Achieve Strong Performance With Threads, Part 4
Focuses on thread groups, volatility, thread-local variables, timers, and the ThreadDeath class. Also describes how various thread concepts combine to finalize objects. |
Avoid Synchronization Deadlocks
Explains how to apply consistent rules for acquiring multiple locks simultaneously, to reduce the likelihood of synchronization deadlocks. |
Can Double-Checked Locking be Fixed?
In this article, Brian Goetz looks at some of the commonly proposed fixes and shows how each of them fails to render the DCL idiom thread-safe under the Java Memory Model. |
Can ThreadLocal Solve the Double-checked Locking Problem?
Explains how to fix the double-checked locking idiom by using thread-local variables and takes a look at its performance. |
Double-Checked Locking: Clever, but Broken
Though many Java books and articles recommend double-checked locking, unfortunately, it is not guaranteed to work in Java. |
Ease Your Multithreaded Application Programming
Takes a look at one of the most-used constructs in multithreaded programming: the producer-consumer scenario. Also shows a Consumer class which facilitates code reuse and simplifies debugging and maintenance in some multithreaded applications. |
Implementing Read-Write Locks in Java
Read-write locks allow multiple threads to acquire a read lock provided no other thread currently has a write lock on the same object. A thread can acquire a write lock if no other thread owns either a read lock or a write lock. |
Multi-threading in Java
Article by Neel V. Kumar. A tour in the land of multithreading in Java. Introduces the mechanisms and demonstrates how to use them in limited but very common cases. |
Programming Java Threads in the Real World, Part 1
Discusses the things you need to know to program threads in the real world. This article assumes you understand the language-level support for threads and focuses on the legion of problems that arise when you try to use these language features. |
Programming Java Threads in the Real World, Part 2
Discusses the perils that can arise when you approach multithreading in a naive way. |
Programming Java Threads in the Real World, Part 3
Looks at how and why you might want to roll your own exclusion semaphores, and presents a lock manager that will help you safely acquire multiple semaphores. |
Programming Java Threads in the Real World, Part 5
Timers let you perform fixed-interval operations, such as animation refreshes. |
Programming Java Threads in the Real World, Part 6
How to implement the Observer pattern (used by AWT/Swing for its event model) in a multithreaded environment. |
Programming Java Threads in the Real World, Part 7
Reader/writer locks let multiple threads safely access a shared resource in an efficient way. |
Programming Java Threads in the Real World, Part 8
Discusses architectural solutions to threading problems. Takes a look at threads from the perspective of an object-oriented designer, and at how to implement threads in an object-oriented environment, focusing on the implementation of asynchronous method |
Singletons with Needles and Thread
Presents two approaches to creating thread-safe singletons. |
The "Double-Checked Locking is Broken" Declaration
Details on the reasons - some very subtle - why double-checked locking cannot be relied upon to be safe. Signed by a number of experts, including Sun engineers. |
Thread Pools and Work Queues
Explores the motivations for thread pools, some basic implementation and tuning techniques, and some common hazards to avoid. |
Thread Synchronization in Java
Producer Consumer, Dining Philosophers, Reader Writer problems. Applet demonstration, design diagram. Source code accessable by e-mail request. |
Thread Synchronization in Java (Sources)
Introduces basic concurrency problems and shows how to solve them by using builtin Java synchronization primitives. (Only sources free accessed without registration) |
Threading Lightly: Exploiting ThreadLocal to Enhance Scalability
Examines ThreadLocal and offers tips for exploiting its power. |
Threading Lightly: Reducing Contention
Explains why contended synchronization is a problem and then explores several techniques for reducing contention, and hence improving scalability. |
Threads 101
Explains from the ground up how to get threads work correctly. (Chuck Allison) |
Why Thread Pools are Important in Java
Explains the use of thread pools to create better performing applications. |
Writing Multithreaded Java Applications
Introduces the Java Thread API, outlines issues involved in multithreading, and offers solutions to common problems. |
