Java的synchronized加在方法上或者对象上有什么区别？

Java的synchronized可以加在方法上，也可以直接加在对象上，从而保证一段代码只能有一个线程在运行，保证线程的同步。

那么这两者究竟有啥区别呢？我们可以看下面的示例代码。

public class SyncTest {

	public static synchronized void testSyncOnStaticMethod() {
		System.out.println("testSyncOnStaticMethod");
		try {
			Thread.sleep(10000);
		} catch (InterruptedException e) {
		}
	}

	public static void testSyncOnClass() {
		synchronized (SyncTest.class) {
			System.out.println("testSyncOnClass");
			try {
				Thread.sleep(10000);
			} catch (InterruptedException e) {
			}
		}
	}

	public synchronized void testSyncOnMethod() {
		System.out.println("testSyncOnMethod");
		try {
			Thread.sleep(10000);
		} catch (InterruptedException e) {
		}
	}

	public void testSyncOnThis() {
		synchronized (this) {
			System.out.println("testSyncOnThis");
			try {
				Thread.sleep(10000);
			} catch (InterruptedException e) {
			}
		}
	}

	public static void case1() {
		// case1
		// 先输出testSyncOnThis或者testSyncOnMethod
		// 然后停顿10秒，再输出另一个
		// 这个现象表明了
		
		// public synchronized void func() {
		// }
		
		// 等价于
		
		// public void func() {
		//     synchronized (this) {
		//     }
		// }
		final SyncTest t1 = new SyncTest();
		new Thread(new Runnable() {

			@Override
			public void run() {
				t1.testSyncOnThis();
			}
		}).start();

		new Thread(new Runnable() {

			@Override
			public void run() {
				t1.testSyncOnMethod();
			}
		}).start();
	}

	public static void case2() {
		// case2
		// 先输出testSyncOnClass或者testSyncOnStaticMethod
		// 然后停顿10秒，再输出另一个
		// 这个现象表明了
		
		// public synchronized static void staticFunc() {
		// }
		
		// 等价于
		
		// public static void staticFunc() {
		//     synchronized (SyncTest.class) {
		//     }
		// }
		new Thread(new Runnable() {

			@Override
			public void run() {
				SyncTest.testSyncOnClass();
			}
		}).start();

		new Thread(new Runnable() {

			@Override
			public void run() {
				SyncTest.testSyncOnStaticMethod();
			}
		}).start();
	}

	public static void main(String[] args) {
		case1();
		case2();
	}
}

从上面的代码我们可以看出synchronized加在方法上本质上还是等价于加在对象上的。

如果synchronized加在一个类的普通方法上，那么相当于synchronized(this)。

如果synchronized加载一个类的静态方法上，那么相当于synchronized(Class对象)。

在使用多线程的时候，知道这个是很关键的，因为synchronized的两种不用用法可能导致两段不相干的代码是互斥的，增加了同步的开销（例如这里的函数testSyncOnThis和testSyncOnMethod，他们在同一个对象this上加了锁），更严重的是可能导致死锁。

注：如果要试验，上面的case1和case2请分开运行（可以跑两次，每次注释掉其中一个语句），这样子可以看得比较清楚。