Doing Two or More Tasks At Once: Threads |
The code segments within a program that access the same object from separate, concurrent threads are called critical sections. In the Java language, a critical section can be a block or a method and are identified with thesynchronized
keyword. The Java platform then associates a lock with every object that has synchronized code.In the producer/consumer example, the
put
andget
methods of theCubbyHole
(page 645) are the critical sections. TheConsumer
should not access theCubbyHole
when theProducer
is changing it, and theProducer
should not modify it when theConsumer
is getting the value. Soput
andget
in theCubbyHole
class should be marked with thesynchronized
keyword.Here's a code skeleton for the
CubbyHole
class:Note that the method declarations for bothpublic class CubbyHole { private int contents; private boolean available = false; public synchronized int get() { ... } public synchronized void put(int value) { ... } }put
andget
contain thesynchronized
keyword. Hence, the system associates a unique lock with every instance ofCubbyHole
(including the one shared by theProducer
and theConsumer
). Whenever control enters a synchronized method, the thread that called the method locks the object whose method has been called. Other threads cannot call a synchronized method on the same object until the object is unlocked.So, when the
Producer
callsCubbyHole
'sput
method, it locks theCubbyHole
, thereby preventing theConsumer
from calling theCubbyHole
'sget
method:When thepublic synchronized void put(int value) { // CubbyHole locked by the Producer .. // CubbyHole unlocked by the Producer }put
method returns, theProducer
unlocks theCubbyHole
.Similarly, when the
Consumer
callsCubbyHole
'sget
method, it locks theCubbyHole
, thereby preventing theProducer
from callingput
:The acquisition and release of a lock is done automatically and atomically by the Java runtime system. This ensures that race conditions cannot occur in the underlying implementation of the threads, thus ensuring data integrity. Synchronization isn't the whole story. The two threads must also be able to notify one another when they've done their job. Learn more about that after a brief foray into reentrant locks.public synchronized int get() { // CubbyHole locked by the Consumer ... // CubbyHole unlocked by the Consumer }
Doing Two or More Tasks At Once: Threads |