One of the problems you encounter while doing
programming is that you must often make sure that only one thread is
running a particular piece of code at the same time (perhaps to
protect some data structure or resource from simultaneous
access). In Java, this is achieved through
synchronization. It works like this:
- A block of code can be marked as synchronized. Each block
is associated with an object, and if no object is given it defaults
to the object that the code belongs to.
- A thread must own the monitor for the associated object to to be
permitted to enter a synchronized block. If it doesn't, it will wait
until it does.
- When a thread exits a synchronized block (or goes into a waiting
state while inside the block), the VM will check if
any other threads are waiting for the monitor, and in that case wakes
one of them.
While this method of synchronization is pretty straightforward
use, it is still possible
to get into a state of deadlock
programmer is not careful. This is often the result of calling
synchronized blocks of code from within other synchronized
blocks. Avoid this at any cost...