通常在方法级别上使用锁是不礼貌的。为什么要通过锁定整个方法来锁定一段不能访问任何共享资源的代码呢?因为每个对象都有一个锁，所以可以创建虚拟对象来实现块级同步。 块级的效率更高，因为它不锁定整个方法。

这里有一些例子

方法级

class MethodLevel {

  //shared among threads
SharedResource x, y ;

public void synchronized method1() {
   //multiple threads can't access
}
public void synchronized method2() {
  //multiple threads can't access
}

 public void method3() {
  //not synchronized
  //multiple threads can access
 }
}

块级别

class BlockLevel {
  //shared among threads
  SharedResource x, y ;

  //dummy objects for locking
  Object xLock = new Object();
  Object yLock = new Object();

    public void method1() {
     synchronized(xLock){
    //access x here. thread safe
    }

    //do something here but don't use SharedResource x, y
    // because will not be thread-safe
     synchronized(xLock) {
       synchronized(yLock) {
      //access x,y here. thread safe
      }
     }

     //do something here but don't use SharedResource x, y
     //because will not be thread-safe
    }//end of method1
 }

(编辑)

对于像Vector和Hashtable这样的集合，当ArrayList或HashMap不同步时，它们是同步的，你需要设置synchronized关键字或调用Collections synchronized方法:

Map myMap = Collections.synchronizedMap (myMap); // single lock for the entire map
List myList = Collections.synchronizedList (myList); // single lock for the entire list

主要的区别是，如果你使用同步块，你可以锁定一个对象，而不是这个，这允许更灵活。

假设您有一个消息队列和多个消息生产者和消费者。我们不希望生产者相互干扰，但是消费者应该能够检索消息，而不必等待生产者。 我们只需要创建一个对象

Object writeLock = new Object();

从现在开始，每当制作人想要添加一条新信息时，我们就会锁定它:

synchronized(writeLock){
  // do something
}

因此，消费者可能仍会阅读，而生产者将被锁定。

关于使用同步块的重要提示:小心你使用的锁对象!

上面user2277816的代码片段说明了这一点，将字符串字面值的引用用作锁定对象。 意识到字符串字面值在Java中是自动互缩的，您应该开始看到问题所在:在字面值“锁”上同步的每段代码都共享同一个锁!这很容易导致完全不相关的代码段发生死锁。

您需要注意的不仅仅是String对象。装箱的原语也是一种危险，因为autoboxing和valueOf方法可以重用相同的对象，这取决于值。

有关更多信息，请参阅: https://www.securecoding.cert.org/confluence/display/java/LCK01-J.+Do+not+synchronize+on+objects+that+may+be+reused

当java编译器将源代码转换为字节码时，它处理同步方法和同步块的方式非常不同。

当JVM执行一个同步方法时，执行线程识别出该方法的method_info结构体设置了ACC_SYNCHRONIZED标志，然后它自动获取对象的锁，调用该方法，并释放锁。如果发生异常，线程自动释放锁。

另一方面，同步方法块绕过了JVM对获取对象锁和异常处理的内置支持，并要求显式地用字节代码编写功能。如果读取带有同步块的方法的字节代码，您将看到十多个额外的操作来管理此功能。

这显示了生成同步方法和同步块的调用:

public class SynchronizationExample {
    private int i;

    public synchronized int synchronizedMethodGet() {
        return i;
    }

    public int synchronizedBlockGet() {
        synchronized( this ) {
            return i;
        }
    }
}

synchronizedMethodGet()方法生成以下字节代码:

0:  aload_0
1:  getfield
2:  nop
3:  iconst_m1
4:  ireturn

下面是synchronizedBlockGet()方法的字节代码:

0:  aload_0
1:  dup
2:  astore_1
3:  monitorenter
4:  aload_0
5:  getfield
6:  nop
7:  iconst_m1
8:  aload_1
9:  monitorexit
10: ireturn
11: astore_2
12: aload_1
13: monitorexit
14: aload_2
15: athrow

One significant difference between synchronized method and block is that, Synchronized block generally reduce scope of lock. As scope of lock is inversely proportional to performance, its always better to lock only critical section of code. One of the best example of using synchronized block is double checked locking in Singleton pattern where instead of locking whole getInstance() method we only lock critical section of code which is used to create Singleton instance. This improves performance drastically because locking is only required one or two times.

在使用同步方法时，如果混合使用静态同步方法和非静态同步方法，则需要格外小心。

注意:静态同步方法和块工作在Class对象上。

public class MyClass {
   // locks MyClass.class
   public static synchronized void foo() {
// do something
   }

   // similar
   public static void foo() {
      synchronized(MyClass.class) {
// do something
      }
   }
}

唯一真正的区别是同步块可以选择在哪个对象上同步。同步方法只能使用'this'(或同步类方法的相应Class实例)。例如，它们在语义上是等价的:

synchronized void foo() {
  ...
}

void foo() {
    synchronized (this) {
      ...
    }
}

后者更灵活，因为它可以竞争任何对象(通常是成员变量)的关联锁。它也更细粒度，因为您可以在块之前和块之后执行并发代码，但仍然在方法中。当然，您也可以通过将并发代码重构为单独的非同步方法来轻松地使用同步方法。使用任何使代码更容易理解的方法。