同步中不同监控对象的用途

Question

Could someone explain the difference between synchronized(this) and synchronized (c)?

I refereed various answers( 1 , 2 , 3 , 4 , 5 ) but not able to understand and getting confused.

public class Check {

    Consumer c = new Consumer(null);

    public void getSynch() {

        synchronized (this) {
            // doing some task
            System.out.println("Start");
        }

        synchronized (c) {
            // doing some task
            System.out.println("End");
        }

    }

}

I am able to understand the synchronized concept but not monitor object. Please explain in a simple way.

Answer 1

synchronized always works on a monitor object (sometimes also called lock or semaphore). Think of it as a token: when a thread enters a synchronized block it grads the token and other threads need to wait for the token to be returned. If you have multiple different monitor objects you basically have different tokens and thus synchronized blocks that operate on different monitors can run in parallel.

There are many possibilities with this and many possible use cases. One could be that multiple instances of a class could run in parallel but need access to a shared and non-threadsafe resource. You then could use that resource or any other object that represents the "token" for that resource as the monitor object.

However, note that there's potential for deadlocks, eg in the following situation:

Block 1:

synchronized(A) {
  //do something with A
  synchronized(B) {
    //do something with B
  }
}

Block 2:

synchronized(B) {
  //do something with B
  synchronized(A) {
    //do something with A
  }
}

Here both outer synchronized blocks could be entered in parallel because the two monitors A and B are available but then need to grab the other monitor and because they are now locked both threads would have to wait - class deadlock.

Also have a look at the dining philosophers problem which handles that topic as well (here the forks could be considered the monitor objects).

Edit:

In your case (the code you've posted), multiple threads could try to call getSynch() on the same instance of Check . The first block synchronizes on the instance itself thus preventing multiple threads from entering that block if called on the same instance.

The second block synchronizes on c which is a different object and could change over time. Assume the first block ( synchronized(this) { ... } ) changes c to reference another instance of Consumer . In that case you could have multiple threads run that block in parallel, eg if one entered the synchronized(c) block before the other thread reassigns c .