Home  Synchronization and concurrency  wait/notify  final  volatile  synchronized keyword  Java threading  Deadlock (and avoiding it)  Java 5: ConcurrentHashMap  Atomic variables  Explicit locks  Queues  Semaphores  CountDownLatch  CyclicBarrier

 Have a Kindle? Sign up to the newsletter  Follow follow the author on Twitter
 RECOMMEND THIS SITE TO FRIENDS/COLLEAGUES:

Synchronization and concurrency before Java 5

Prior to Java 5, there were basically five means to correctly synchronize data between threads ("shared" here means "accessed by multiple threads"):

• Place code that accesses shared data in a synchronized block;
• Define synchronized methods;
• In combination with synchronization, use the wait / notify paradigm to allow one thread to signal to another, possibly with a timed wait;
• Declare a shared variable as volatile, meaning that individual threads are not allowed to cache copies of that variable in local memory or registers;
• Rely on the inherent synchronization of the class loader;
• "Piggybacking" on other synhcronization.

For most programmers, the first two of these are probably the bread-and-butter means of synchronizing data. I suspect that the last two or three on this list are unknown to many otherwise experienced Java programmers. (The last is actually rare and generally unrecommended, but we consider it for completeness.) We'll review each of these methods briefly here, starting with the synchronized keyword.