reentrant synchronization

Question

Can you tell me if following invocations are reentrant or not?

public class Foo {

  public synchronized void doSomething() {}

  public synchronized void doAnot         


        

Answer 1

first of all locks are applicable on objects so need to create the object and then apply the lock.

are 2 continuous invocations in method doToo() reentrant? I

In your case they are not re-entrant . if code is something like below then they will be re-entrant .

  public class Foo {

 public synchronized void doSomething() {
        doAnotherSomething();
}

 public synchronized void doAnotherSomething() {}
}

Once lock has been acquired on one object then on same object it can traverse like in above case.

Answer 2

First of all, regarding reentrant locks in Java:

Synchronized blocks in Java are reentrant. This means, that if a Java thread enters a synchronized block of code, and thereby take the lock on the monitor object the block is synchronized on, the thread can enter other Java code blocks synchronized on the same monitor object.

Taken from here.

The two consecutive calls you described (in doToo) will not be interfered unless another object has a reference to Too's private Foo, since, to access foo, one needs to lock Too. However, the calls do not invoke reentry as the locks are acquired and released for every call. They would be reentrant if doSomething called doAnotherSomething or vice versa.

Answer 3

That depends entirely on what other threads are accessing. Can another thread take over the CPU between those functions? Yes. Will there be a race condition? Depends on many factors.

From what you posted foo.doSomething will be locked on foo, then released, then locked again upon entry to doAnotherSomething. So if another thread not locked on the same Too object tries to manipulate foo they will be able to do so between doSomething and doAnotherSomething. If everyone synchronized on the same Too object before manipulating the underlying foo object, then those two methods of foo will not have state manipulated between calls because the Too object method will block other threads until completion. Thus if you have a problem or not depends on your other accessors.

There is no reentrance here from what you posted, but java is ok with reentrant synchronization as Amir posted.