获取另一个对象在同步块上的锁

Question

i'm currently studying the multithreading concept thoroughly and i'v noticed that whenever a synchronized block is discussed, the lock on this object is acquired. eg:

synchronized(this) {}

but, is there any reason to give another object as the argument for synchronized? or is it an inadvisable pattern?

Answer 1

You can use a common object as follows.

static final Object lock=new Object();

Then you can parse this into synchronized block as follows

synchronized(lock){

 }

Only requirement here is you have to share common object. Then each path(different object) locked based on this object.

I think you are having issue with why we use other object.

If we want to locked different path by different Threads we have to locked each path. So we have to use third object. Then when one object quires that lock object other threads has to wait until that lock is resealed. But same thread which acquire the lock can continue.

Answer 2

You can use a third party object as a lock . Generally such objects can be used to achieve synchronization to shared resources between different objects , which will be forced to acquire this third party object lock before executing certain piece of code.

Answer 3

An example why locking on something else might be beneficial:

final List<Object1> firstList = new List<>();
final List<Object2> secondList = new List<>();

// ...

public Object readFromListOne() {
  synchronized(firstList) {
    return firstList.remove(0);
  }
}

public Object readFromListTwo() {
  synchronized(secondList) {
    return secondList.remove(0);
  }
}

Here threads can access both lists simultaneously, while a synchronized(this) would have locked both calls, even though it isn't necessary.

Btw: a concurrent list will render all this synchronization obsolete

Answer 4

synchronized(this) {}

That means that any other thread that synchronizes on this will have to release/wait until you release/wait the lock before it can proceed.

  synchronized(somethingElse) {}

That means the lock happens on now with somethingElse .

So there is a clear difference and depends on what you are synchronized.