Question

In Java, the idiomatic way to declare critical sections in the code is the following:

private void doSomething() {   // thread-safe code   synchronized(this) {     // thread-unsafe code   }   // thread-safe code } 

Almost all blocks synchronize on this, but is there a particular reason for this? Are there other possibilities? Are there any best practices on what object to synchronize on? (such as private instances of Object?)

Answer 1

First, note that the following code snippets are identical.

public void foo() {     synchronized (this) {         // do something thread-safe     } } 

and:

public synchronized void foo() {     // do something thread-safe } 

do exactly the same thing. No preference for either one of them except for code readability and style.

When you do synchronize methods or blocks of code, it’s important to know why you are doing such a thing, and what object exactly you are locking, and for what purpose.

Also note that there are situations in which you will want to client-side synchronize blocks of code in which the monitor you are asking for (i.e. the synchronized object) is not necessarily this, like in this example :

Vector v = getSomeGlobalVector(); synchronized (v) {     // some thread-safe operation on the vector } 

I suggest you get more knowledge about concurrent programming, it will serve you a great deal once you know exactly what’s happening behind the scenes. You should check out Concurrent Programming in Java, a great book on the subject. If you want a quick dive-in to the subject, check out Java Concurrency @ Sun