  |
JKeyLockManager - http://code.google.com/p/jkeylockmanager/
Provides fine-grained locking with application specific keys. [Open Source] |
| |
Java Concurrency with Thread Gates - http://www.javaworld.com/javaworld/jw-03-2009/jw-03-java-concurrency-with-thread-gates.html
The thread gate pattern is an effective tool for managing thread concurrency, but not many developers know about it. Introduces the concept of thread gates, and then shows how to implement them in a multithreaded prime-number generator. |
| |
Double-Checked Locking: Clever, but Broken - http://www.javaworld.com/javaworld/jw-02-2001/jw-0209-double_p.html
Though many Java books and articles recommend double-checked locking, unfortunately, it is not guaranteed to work in Java. |
| |
Extending Java to Support Shared Resource Protection and Deadlock Detection in Threads Programming - http://www.acm.org/crossroads/xrds4-2/dynac.html
The current Java thread specification does not adequately provide for the protection of shared resources or for deadlock detection. A model is introduced and implemented that can provides shared resource protection and deadlock detection. (ACM Crossroads) |
| |
Safe construction techniques - http://www.ibm.com/developerworks/library/j-jtp0618.html
Concurrent programming in Java applications is more complicated than it looks: there are several subtle (and not so subtle) ways to create data races and other concurrency hazards in Java programs. In this article, Brian Goetz looks at a common threading hazard: allowing the this reference to escape during construction. |
| |
Hey, where'd my thread go? - http://www.ibm.com/developerworks/library/j-jtp0924.html
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. |
| |
Threading Lightly: Exploiting ThreadLocal to Enhance Scalability - http://www.ibm.com/developerworks/java/library/j-threads3.html
Examines ThreadLocal and offers tips for exploiting its power. By Brian Goetz. |
| |
Double-checked Locking and the Singleton Pattern - http://www.ibm.com/developerworks/java/library/j-dcl.html
Examines the roots of the double-checked locking idiom, why it was developed, and why it doesn't work. |
| |
Programming Java Threads in the Real World, Part 1 - http://www.javaworld.com/javaworld/jw-09-1998/jw-09-threads_p.html
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. |
| |
Thread Pools and Work Queues - http://www.ibm.com/developerworks/library/j-jtp0730.html
Explores the motivations for thread pools, some basic implementation and tuning techniques, and some common hazards to avoid. |
| |
Going Atomic - http://www.ibm.com/developerworks/java/library/j-jtp11234/
Explains how the new atomic variable classes in JDK 5.0 enable the development of highly scalable nonblocking algorithms in the Java language. |
| |
Threading Lightly: Reducing Contention - http://www.ibm.com/developerworks/java/library/j-threads2.html
Explains why contended synchronization is a problem and then explores several techniques for reducing contention, and hence improving scalability. |
| |
Java Concurrency / Multithreading - Tutorial - http://www.vogella.de/articles/JavaConcurrency/article.html
This article describes how to do concurrent programming with Java and the Java 5.0 concurrency collection. Covers threads, the executor framework (thread pools), futures, callables, deadlocks and the fork-join framework. |
| |
Can ThreadLocal Solve the Double-checked Locking Problem? - http://www.javaworld.com/javaworld/jw-11-2001/jw-1116-dcl_p.html
Explains how to fix the double-checked locking idiom by using thread-local variables and takes a look at its performance. |
| |
Avoid Synchronization Deadlocks - http://www.javaworld.com/javaworld/jw-10-2001/jw-1012-deadlock_p.html
Explains how to apply consistent rules for acquiring multiple locks simultaneously, to reduce the likelihood of synchronization deadlocks. |
| |
Achieve Strong Performance With Threads, Part 1 - http://www.javaworld.com/javaworld/jw-05-2002/jw-0503-java101.html
Gives an introduction to threads and explores the Thread class and runnables. |
| |
Programming Java Threads in the Real World, Part 9 - http://www.javaworld.com/javaworld/jw-06-1999/jw-06-toolbox_p.html
Discussion of two more architectural solutions to threading problems: a synchronous dispatcher (or 'reactor') and an asynchronous dispatcher (or 'active object'). |
| |
Programming Java Threads in the Real World, Part 7 - http://www.javaworld.com/javaworld/jw-04-1999/jw-04-toolbox_p.html
Reader/writer locks let multiple threads safely access a shared resource in an efficient way. |
| |
Programming Java Threads in the Real World, Part 5 - http://www.javaworld.com/javaworld/jw-02-1999/jw-02-toolbox_p.html
Timers let you perform fixed-interval operations, such as animation refreshes. |
| |
Programming Java Threads in the Real world, Part 4 - http://www.javaworld.com/javaworld/jw-12-1998/jw-12-toolbox_p.html
A condition variable adds to wait the ability to not wait when the condition you're waiting for has already taken place; and a counting semaphore lets you control a pool of resources without sucking up machine cycles in polling loops. |
| |
Programming Java Threads in the Real World, Part 2 - http://www.javaworld.com/javaworld/jw-10-1998/jw-10-toolbox_p.html
Discusses the perils that can arise when you approach multithreading in a naive way. |
| |
Programming Java Threads in the Real World, Part 3 - http://www.javaworld.com/javaworld/jw-11-1998/jw-11-toolbox_p.html
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. |
| |
Achieve Strong Performance With Threads, Part 2 - http://www.javaworld.com/javaworld/jw-06-2002/jw-0607-java101.html
Explains synchronization, Java's synchronization mechanism, and two problems that arise when developers fail to use that mechanism correctly. |
| |
Achieve Strong Performance With Threads, Part 3 - http://www.javaworld.com/javaworld/jw-07-2002/jw-0703-java101.html
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 - http://www.javaworld.com/javaworld/jw-08-2002/jw-0802-java101.html
Focuses on thread groups, volatility, thread-local variables, timers, and the ThreadDeath class. Also describes how various thread concepts combine to finalize objects. |
| |
Seminar: Concurrent Programming in Java - http://www.angelikalanger.com/Courses/ConcurrentJava.htm
A course covering all aspects of multi-thread programming in Java from plain synchronization over Java 5.0 concurrency utilities to memory model issues. |
| |
Writing Multithreaded Java Applications - http://www.ibm.com/developerworks/library/j-thread.html
Introduces the Java Thread API, outlines issues involved in multithreading, and offers solutions to common problems. By Alex Roetter. |
| |
Concurrent Programming with Java Lab - http://astha.8m.net/CPwJ/index.html
Lab. manual by Astha Ekadiyanto. |
| |
Simple Java Thread Management Library (SJT.Mgmt) - http://simplethread.sourceforge.net/
An easy to use library for adding thread management in Java applications. The library comes from early experience with JServ's lack of thread management, and recent posts to the java developer forums. [Open source] |
| |
Thread Synchronization in Java - http://www.sws.bfh.ch/~fischli/threads/
Producer Consumer, Dining Philosophers, Reader Writer problems. Applet demonstration, design diagram. Source code accessible by e-mail request. |
| |
Thread Synchronization in Java (Sources) - http://devcentral.iticentral.com/articles/Java/thread_sync/code.html
Introduces basic concurrency problems and shows how to solve them by using builtin Java synchronization primitives. (Only sources free accessed without registration) |
| |
Implementing Read-Write Locks in Java - http://www.asingh.net/technical/rwlocks.html
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. |
| |
Can Double-Checked Locking be Fixed? - http://www.javaworld.com/javaworld/jw-05-2001/jw-0525-double_p.html
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. |
| |
Programming Java Threads in the Real World, Part 8 - http://www.javaworld.com/javaworld/jw-05-1999/jw-05-toolbox_p.html
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 methods. |
| |
Warning! Threading in a Multiprocessor World - http://www.javaworld.com/javaworld/jw-02-2001/jw-0209-toolbox_p.html
Many authors advocate the double-checked locking idiom to access a Singleton object in an intuitively thread-safe way. Unfortunately, for counterintuitive reasons, double-checked locking doesn't work in Java. |