Java Threading - Synchronized code

Question

Why do you have to specify, which object has locked a synchronized block of code?

You don't have to specify which object has locked a synchronized method as it is always locked by 'this' (I believe).

I have two questions:

• Why can't you block a none static method with an object other than 'this' ?
• Why do you have to specify the object that has blocked synchronized code?

I have read chapter nine of SCJP for Java 6, but I am still not clear on this.

I realize it is probably a basic question, but I am new to Threading.

Answer 1

Why can't you block a none static method with an object other than 'this' ?

You can:

public void foo() {
    synchronized (lock) {
        ...
    }
}

Why do you have to specify the object that has blocked synchronized code?

Because that's how the language designers chose to design the language. synchronized, when used on instance methods, implicitely uses this as the lock. synchronized when used on a block must explicitely specify the lock.

Answer 2

You can. The code

synchronized foo() {
    // some stuff
}

Is logically equal to code

foo() {
    synchronized(this) {
        // some stuff
    }
}

I said "logically" because these 2 examples generate different byte code.

If method foo() is static synchronization is done of class object.

However you can wish to create several synchronized blocks that are synchronized on different objects into one class or even into one method. In this case you can use synchronized (lock) where lock is not this:

foo() {
    synchronized(one) {}
    ///..........
    synchronized(two) {}
}

Answer 3

1. You can lock with any instance of an object but programmers usually use this or locker...
2. Because it restrict access to that part of code by other threads (unit of code processing) so you make sure whole of that part run in consistence and nothing (i.e. a variable) would be alerted by another thread.

Consider:

a = 1;
a++;

Thread one reaches second line and you expect a = 2 but another thread executes first line and instead of 2 you have a = 1 for first thread and a = 2 for second thread. Now:

synchronized (whatever)
{
   a = 1;
   a++;
}

Now second thread would be blocked from entering into the code block (synchronized body) until first one leaves it (release the lock).

Answer 4

You can specify any object you want which should have the lock on the synchronized code block. Actually, you shouldn't use synchronize(this) at all (or maybe be careful about it, see Avoid synchronized(this) in Java?).

Answer 5

EVERY object has a lock on which you can synchronize:

final Object lock = new Object() synchronized ( lock ) { ... }

If you want to synchronize the whole method, you cannot say on which object, so it is always "this" object.

synchronized foo() {....}

The first way of locking is better, by the way.

Answer 6

It is not recommended to lock each method with this as it reduces the concurrency in most cases. So it is recommended to use Lock Stripping in which only the specific part of the code that needs to be protected is kept in synchronized block.

It is a practice that is explained well in Java Concurrency in Practice. But note this book is useful only when you have some basic experience with threading.

Some nuggets to keep in mind:

• Do not overuse synchronization
• use method level synchronization only when the whole method needs to be protected

• Use different locks to protect two unrelated entities, which will increase the chances of concurrency. or else for reading or writing two unrelated entities threads will block on same lock.

  public void incrementCounter1(){
       synchronized(lockForCounter1){
           counter1++;
       }
  }  
  
  public void incrementCounter2(){
       synchronized(lockForCounter2){
           counter2++;
       } 
  }
  

Answer 7

From the concurrency tutorial, the Synchronized methods part:

To make a method synchronized, simply add the synchronized keyword to its declaration:

public class SynchronizedCounter {
private int c = 0;

public synchronized void increment() {
    c++;
}

public synchronized void decrement() {
    c--;
}

public synchronized int value() {
    return c;
}
}

If count is an instance of SynchronizedCounter, then making these methods synchronized has two effects:

• First, it is not possible for two invocations of synchronized methods on the same object to interleave. When one thread is executing a synchronized method for an object, all other threads that invoke synchronized methods for the same object block (suspend execution) until the first thread is done with the object.

• Second, when a synchronized method exits, it automatically establishes a happens-before relationship with any subsequent invocation of a synchronized method for the same object. This guarantees that changes to the state of the object are visible to all threads.

Simply put, that's how synchronization in Java works.

You don't have to specify which object has locked a synchronized method as it is always locked by 'this' (I believe).

True for instance methods, for static methods it locks upon the class object.

Why can't you block a none static method with an object other than 'this' ?

Note that:

 public synchronized void increment() {
  c++;
 }

is equivalent in behavior to:

 public  void increment() {
  synchronized(this) {
     c++;
  }
 }

In this code snippet you can replace this with any object you wish.

Why do you have to specify the object that has blocked synchronized code?

Some, let's call it critical, block of code is to be ran only sequentially, but in uncontrolled concurrent environment it is possible that it will be ran in parallel. That's why synchronization mechanisms exists.

So we can divide the code like this:

• the code safe to be ran in parallel (default situation)
• the code that has to be synchronized (must be marked somehow)

That markation is made via the synchronized keyword and the corresponding lock object.

If you have two different critical code blocks that must not be ran together, they'll both have the synchronized keyword, and let's say they have the same lock object.

While the first block is executing, the lock object becomes "locked". If during that time the second block needs to get executed, the first command of that code block is:

synchronized(lock) {

but that lock object is in locked state because the first block is executing. The execution of the second block halts on that statement until the first block finishes the execution, and unlocks the state of the lock object. Then the second block may proceed with the execution (and lock the lock object again).

That mechanism is called the mutual exclusion and the lock is a general concept not tied to the Java programming language.

The details of the "lock object locking" process can be found here.

Answer 8

I think your two questions actually are same. let's say if you wanna synchronized a method m of object a between multiple threads, you need a common base system or channel that threads can talk to, this is actually what object lock offers, so when you wanna a method of a object be synchronized there is no need for another object lock to do this, because the object you access itself has this lock, that's how and why lanuage designed.

while synchronized a block is not the same thing, threads can have different talking base other than this object itself, for instance, you can set a same object as synchronized object lock for synchronized block, so all objects of this Class can be synchronized at that block!