The Java TM Tutorial

| Start of Tutorial > Start of Trail > Start of Lesson | Search

Trail: Essential Java Classes
Lesson: Doing Two or More Tasks At Once: Threads

## Reaquiring a Lock

> The Java runtime system allows a thread to re-acquire a lock that it already holds because Java locks are reentrant. Reentrant locks are important because they eliminate the possibility of a single thread deadlocking itself on a lock that it already holds.

> Consider this class:

> >     public class Reentrant {
> >         public synchronized void a() {
> >     	b();
> >     	System.out.println("here I am, in a()");
> >         }
> >         public synchronized void b() {
> >     	System.out.println("here I am, in b()");
> >         }
> >     }

> `Reentrant` contains two synchronized methods: `a` and `b`. The first synchronized method, `a`, calls the other synchronized method, `b`.

> When control enters method `a`, the current thread acquires the lock for the `Reentrant` object. Now, `a` calls `b` and because `b` is also synchronized the thread attempts to acquire the same lock again. Because Java supports reentrant locks, this works. The current thread can acquire the `Reentrant` object's lock again and both `a` and `b` execute to conclusion as is evidenced by the output:

> >     here I am, in b()
> >     here I am, in a()

> In systems that don't support reentrant locks, this sequence of method calls would cause deadlock.

| Start of Tutorial > Start of Trail > Start of Lesson | Search