One of the most common situations in concurrent programming occurs when more than one execution thread shares a resource. In a concurrent application, it is normal for multiple threads to read or write the same data structure or have access to the same file or database connection. These shared resources can provoke error situations or data inconsistency, and we have to implement mechanisms to avoid these errors. These situations are called race conditions and they occur when different threads have access to the same shared resource at the same time. Therefore, the final result depends on the order of the execution of threads, and most of the time, it is incorrect. You can also have problems with change visibility. So if a thread changes the value of a shared variable, the changes would only be written in the local cache of that thread; other threads will not have access to the change (they will only...

In this recipe, you will learn how to use one of the most basic methods of synchronization in Java, that is, the use of the synchronized keyword to control concurrent access to a method or a block of code. All the synchronized sentences (used on methods or blocks of code) use an object reference. Only one thread can execute a method or block of code protected by the same object reference.

When you use the synchronized keyword with a method, the object reference is implicit. When you use the synchronized keyword in one or more methods of an object, only one execution thread will have access to all these methods. If another thread tries to access any method declared with the synchronized keyword of the same object, it will be suspended until the first thread finishes the execution of the method. In other words, every method declared with the synchronized keyword is a critical section, and Java...

A classic problem in concurrent programming is the producer-consumer problem. We have a data buffer, one or more producers of data that save it in the buffer, and one or more consumers of data that take it from the buffer.

As the buffer is a shared data structure, we have to control access to it using a synchronization mechanism, such as the synchronized keyword, but here we have more limitations. A producer can't save data in the buffer if it's full, and a consumer can't take data from the buffer if it's empty.

For these types of situations, Java provides the wait(), notify(), and notifyAll() methods implemented in the Object class. A thread can call the wait() method inside a synchronized block of code. If it calls the wait() method outside a synchronized block of code, JVM throws an IllegalMonitorStateException exception. When the thread calls the wait...

Java provides another mechanism for synchronizing blocks of code. It's a more powerful and flexible mechanism than the synchronized keyword. It's based on the Lock (of the java.util.concurrent.locks package) interface and classes that implement it (as ReentrantLock). This mechanism presents some advantages, which are as follows:

• It allows you to structure synchronized blocks in a more flexible way. With the synchronized keyword, you only have control over a synchronized block of code in a structured way. However, the Lock interface allows you to get more complex structures to implement your critical section.
• The Lock interface provides additional functionalities over the synchronized keyword. One of the new functionalities is implemented by the tryLock() method. This method tries to get control of the lock, and if it can't, because it's used by another...

One of the most significant improvements offered by locks is the ReadWriteLock interface and the ReentrantReadWriteLock class, the unique class that implements that interface. This class has two locks: one for read operations and one for write operations. There can be more than one thread using read operations simultaneously, but only one thread can use write operations. If a thread is doing a write operation, other threads can't write or read.

In this recipe, you will learn how to use a ReadWriteLock interface by implementing a program that uses it to control access to an object that stores the prices of two products.

You should read the Synchronizing a block of code with a lock recipe to better...

A lock may be associated with one or more conditions. These conditions are declared in the Condition interface. The purpose of these conditions is to allow threads to have control of a lock and check whether a condition is true or not. If it's false, the thread will be suspended until another thread wakes it up. The Condition interface provides the mechanisms to suspend a thread and wake up a suspended thread.

A classic problem in concurrent programming is the producer-consumer problem. We have a data buffer, one or more producers of data that save it in the buffer, and one or more consumers of data that take it from the buffer, as explained earlier in this chapter.

In this recipe, you will learn how to implement the producer-consumer problem using locks and conditions.

The StampedLock class provides a special kind of lock that is different from the ones provided by the Lock or ReadWriteLock interfaces. In fact, this class doesn't implement these interfaces, but the functionality it provides is very similar.

The first point to note about this kind of lock is that its main purpose is to be a helper class to implement thread-safe components, so its use will not be very common in normal applications.

The most important features of StampedLock locks are as follows:

• You can obtain control of the lock in three different modes:
  • Write: In this mode, you get exclusive access to the lock. No other thread can have control of the lock in this mode.
  • Read: In this mode, you have non-exclusive access to the lock. There can be other threads that have access to the lock in this mode or the Optimistic Read mode.
  • Optimistic Read: Here, the thread...