31

Lets say we have these 2 sample code :

public synchronized void getSomething(){
     this.hello = "hello World";
}

and this one

public void getSomething(){
   synchronized(this){
     this.hello = "hello World";
   }
}

So some one can tell me what's the difference now?

Tarik
  • 79,711
  • 83
  • 236
  • 349

3 Answers3

39

The two different methods are functionally equivalent. There may be a very small performance difference:

At the bytecode level, the synchronized method advertises its need for synchronization as a bit set in the method's access flag. The JVM looks for this bit flag and synchronizes appropriately.

The synchronized block implements its synchronization through a sequence of bytecode operations stored in the class file's definition of the method.

So the synchronized method might potentially execute slightly faster and take up less space in terms of bytecode.

Again, the two are, by specification, functionally identical.

I'm guessing that the performance difference is negligible and code style guidelines should win out. Some compilers might even optimize away the block into an access flag. And JIT may take the performance difference away.

Mike Clark
  • 10,027
  • 3
  • 40
  • 54
20

Check out this portion of this article:

http://www.ibm.com/developerworks/ibm/library/it-haggar_bytecode/#4

It explains that while functionally congruent (synchronizing a method either locks on the instance Object or in the case of a static method the Class object of the class in which the method resides), synchronizing a method is much more optimal because rather than synchronizing in bytecode (as the synchronized block statements do), it synchronizes at the JVM level.

Carrotman42
  • 1,744
  • 1
  • 14
  • 19
  • 1
    +1. Finally a hint of the mechanic details and a nice link (covering the exact question no less) to back it up. –  Dec 09 '10 at 05:53
9

One difference is the granularity of the code that is synchronized. In the first example you are essentially locking the entire method, while in the second example only a section of the method will be locked. The second approach is better for long methods whose bodies do not need to be completely synchronized. Its best to only lock when you need to and release that lock for other threads as soon as possible.

D.C.
  • 15,340
  • 19
  • 71
  • 102
  • 1
    But what if, as above, the `synchronized(this)` block surrounds the *entire body*, as per the examples? Is there a difference in byte-code generation or monitor object? –  Dec 09 '10 at 05:50