Question

Out of the below two synchronization strategy, which one is optimized (as in processing and generated byte code) and also the scenario in which one should use one of them.

public synchronized void addName(String name) 
{
       lastName = name;
       nameCount++;
       nameList.add(name);
}

or

public void addName(String name) {
    synchronized(this) {
        lastName = name;
        nameCount++;
        nameList.add(name);
    }

}

Also what is advisiable way to handle concurrency:

1. using java.util.concurrent package
2. using the above low level methods
3. using Job or UIJob API (if working in eclipse PDE environment)

Thanks

Answer 1

which one is optimized (as in processing and generated byte code)

According to this IBM DeveloperWorks Article Section 1, a synchronized method generates less bytecode when compared to a synchronized block. The article explains why.

Snippet from the article:

When the JVM executes a synchronized method, the executing thread identifies that the method’s method_info structure has the ACC_SYNCHRONIZED flag set, then it automatically acquires the object’s lock, calls the method, and releases the lock. If an exception occurs, the thread automatically releases the lock.

Synchronizing a method block, on the
other hand, bypasses the JVM’s
built-in support for acquiring an
object’s lock and exception handling
and requires that the functionality be
explicitly written in byte code. If
you read the byte code for a method
with a synchronized block, you will
see more than a dozen additional
operations to manage this
functionality. Listing 1 shows calls
to generate both a synchronized method
and a synchronized block:

Edited to address first comment

To give other SOers credit, here is a good discussion about why one would use a sync. block. I am sure you can find more interesting discussions if you search around 🙂

Is there an advantage to use a Synchronized Method instead of a Synchronized Block?

I personally have not had to use a sync. block to lock on another object other than this, but that is one use SOers point out about sync. blocks.