1. Java Concurrency Utilities - java.util.concurrent
2. Java BlockingQueue
3. ArrayBlockingQueue
4. DelayQueue
5. LinkedBlockingQueue
6. PriorityBlockingQueue
7. SynchronousQueue
8. BlockingDeque
9. LinkedBlockingDeque
10. ConcurrentMap
11. ConcurrentNavigableMap
12. CountDownLatch
13. CyclicBarrier
14. Exchanger
15. Semaphore
16. Java ExecutorService
17. Java Callable
18. Java Future
19. ThreadPoolExecutor
20. ScheduledExecutorService
21. Java ForkJoinPool
22. Java Lock
23. ReadWriteLock
24. AtomicBoolean
25. AtomicInteger
26. AtomicLong
27. AtomicReference
28. AtomicStampedReference
29. AtomicIntegerArray
30. AtomicLongArray
31. AtomicReferenceArray

• ReadWriteLock Locking Rules
• ReadWriteLock Implementations
• ReadWriteLock Code Example

A java.util.concurrent.locks.ReadWriteLock is an advanced thread lock mechanism. It allows multiple threads to read a certain resource, but only one to write it, at a time.

The idea is, that multiple threads can read from a shared resource without causing concurrency errors. The concurrency errors first occur when reads and writes to a shared resource occur concurrently, or if multiple writes take place concurrently.

In this text I only cover Java's built-in ReadWriteLock. If you want to read more about the theory behind the implemenation of a ReadWriteLock, you can read it in my text on Read Write Locks in my Java Concurrency tutorial.

ReadWriteLock Locking Rules

The rules by which a thread is allowed to lock the ReadWriteLock either for reading or writing the guarded resource, are as follows:

ReadWriteLock Implementations

ReadWriteLock is an interface. Thus, to use a ReadWriteLock

The java.util.concurrent.locks package contains the following ReadWriteLock implementation:

• ReentrantReadWriteLock

ReadWriteLock Code Example

Here is a simple code example that shows how to create a ReadWriteLock and how to lock it for reading and writing:

ReadWriteLock readWriteLock = new ReentrantReadWriteLock();


readWriteLock.readLock().lock();

    // multiple readers can enter this section
    // if not locked for writing, and not writers waiting
    // to lock for writing.

readWriteLock.readLock().unlock();


readWriteLock.writeLock().lock();

    // only one writer can enter this section,
    // and only if no threads are currently reading.

readWriteLock.writeLock().unlock();

Notice how the ReadWriteLock actually internally keeps two Lock instances. One guarding read access, and one guarding write access.