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.
Threading Lightly: Synchronization is not the Enemy
Takes a look at the semantics and the performance penalty of Java's synchronized keyword.
Writing Multithreaded Java Applications
Introduces the Java Thread API, outlines issues involved in multithreading, and offers solutions to common problems.
A Critique of Java for Concurrent Programming
Presents some predictions of how concurrent programming might evolve during until 2015. (September, 2005)
Going Atomic
Explains how the new atomic variable classes in JDK 5.0 enable the development of highly scalable nonblocking algorithms in the Java language. (November 23, 2004)
Hey, where'd my thread go?
If you're not careful, threads can disappear from server applications without a (stack) trace. In this article, threading expert Brian Goetz offers some techniques for both prevention and detection of threads going AWOL. (September, 2002)
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. (August, 2002)
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. (July, 2002)
Thread Pools and Work Queues
Explores the motivations for thread pools, some basic implementation and tuning techniques, and some common hazards to avoid. (July, 2002)
Achieve Strong Performance With Threads, Part 2
Explains synchronization, Java's synchronization mechanism, and two problems that arise when developers fail to use that mechanism correctly. (June, 2002)
Achieve Strong Performance With Threads, Part 1
Gives an introduction to threads and explores the Thread class and runnables. (May, 2002)
Double-checked Locking and the Singleton Pattern
Examines the roots of the double-checked locking idiom, why it was developed, and why it doesn't work. (May, 2002)
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. (February, 2002)
Singletons with Needles and Thread
Presents two approaches to creating thread-safe singletons. (January 25, 2002)
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. (November, 2001)
Avoid Synchronization Deadlocks
Explains how to apply consistent rules for acquiring multiple locks simultaneously, to reduce the likelihood of synchronization deadlocks. (October, 2001)
Threads 101
Explains from the ground up how to get threads work correctly. (Chuck Allison) (June, 2001)
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. (May, 2001)
Results: Previous 1 2 3 4 5 6 7 8 9 10 Next
Site
Menu 
