What is the difference between a synchronized function and synchronized block?

Question

what is the difference between

public synchronized void addition()
{
   //something;
}

and

public void addtion()
{
     synchronized (//something)
     {
        //something;
     }
}

If I am wrong Ignore this question.

Answer 1

public synchronized void addition() {...}

is equivalent to

public void addition() {
  synchronized(this) { ... }
}

Now, if you replace the this with a different object reference, the locking will be done using that other object's monitor.

Answer 2

The second one doesn't compile. If you meant

public void addition()
{
     synchronized (this)
     {
        //something;
     }
}

Then they're equivalent.

Answer 3

If the second example is synchronized (this), then there's no difference. If it's something else, then the lock object is different.

Answer 4

public synchronized void addition()
{
   //something;
}

is the same as:

public void addtion()
{
     synchronized (this)
     {
        //something;
     }
}

Whereas, in your second example, you may want to synchronize using something different from this.

Answer 5

it the first one only one thread can execute whole method at a time whereas in second one only one thread can execute that synchronized block if not used this as parameter.

here is a duplicate of it Is there an advantage to use a Synchronized Method instead of a Synchronized Block?

Answer 6

Synchronized method synchronizes on "this" object. And if it is a block you can choose any object as a lock.

Answer 7

I)

public synchronized void addition() 
{
    //something; 
}

II)

public void addtion() 
{      
    synchronized (//something)      
    {
        //something;      
    }
} 

In version I (method level synchronization), at a time, complete body of method can only be executed by one thread only.

however, version II is more flexible cause it's called block level synchronization and you can add some lines above synchronized (//something) to execute them parallely. it should be synchronized (this)

version II should be preferred as only that code needs to be multithreaded (within synchronized) which are critical.