Java中synchronized 用在实例方法和对象方法上面的区别

        在Java中，synchronized 是用来表示同步的，我们可以synchronized 来修饰一个方法。也可以synchronized 来修饰方法里面的一个语句块。

      修饰实例方法：

public synchronized void normalMethod() throws InterruptedException {
	for (int i = 0; i < 10; i++) {
		Thread.sleep(1000);
		System.out.println("normalMethod:" + i);
	}
}

      修饰类方法（static 方法）：

public static synchronized void staticMethod() throws InterruptedException {
	for (int i = 0; i < 10; i++) {
		Thread.sleep(500);
		System.out.println("staticMethod:" + i);
	}
}

       修饰方法里面语句块：

public static void staticMethod() throws InterruptedException  {  
        synchronized (locks) {  
            for (int i = 0; i < 10; i++)  {  
                Thread.sleep(1000);  
                System.out.println("staticMethod:" + i);  
           }  
       }  
}  

      注意：这里不能用synchronized修饰方法外面的语句块（我把他叫做类语句块），虽然我们可以在方法外面定义语句块，这样做会遇到编译错误，这里涉及到了Java里面的对象初始化的部分知识。大概的原因就是synchronized锁住的是对象，当初始化对象的时候，JVM在对象初始化完成之前会调用方法外面的语句块，这个时候对象还不存在，所以就不存在锁了。

      那么，在static方法和非static方法前面加synchronized到底有什么不同呢？

      static的方法属于类方法，它属于这个Class（注意：这里的Class不是指Class的某个具体对象），那么static获取到的锁，就是当前调用这个方法的对象所属的类(Class，而不再是由这个Class产生的某个具体对象了)。而非static方法获取到的锁，就是当前调用这个方法的对象的锁了。所以，他们之间不会产生互斥。

      实例1：

package com.bijian.thread;

public class SynchronizedTest {

	public static synchronized void staticMethod() throws InterruptedException {
		for (int i = 0; i < 10; i++) {
			Thread.sleep(500);
			System.out.println("staticMethod:" + i);
		}
	}

	public synchronized void normalMethod() throws InterruptedException {
		for (int i = 0; i < 10; i++) {
			Thread.sleep(1000);
			System.out.println("normalMethod:" + i);
		}
	}

	public static void main(String[] args) {
		final SynchronizedTest synchronizedTest = new SynchronizedTest();
		Thread thread = new Thread(new Runnable() {
			public void run() {
				try {
					synchronizedTest.normalMethod();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}, "a");

		Thread thread1 = new Thread(new Runnable() {
			public void run() {
				try {
					SynchronizedTest.staticMethod();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}, "b");

		thread1.start();
		thread.start();
	}
}

       运行结果：

staticMethod:0
normalMethod:0
staticMethod:1
staticMethod:2
normalMethod:1
staticMethod:3
staticMethod:4
normalMethod:2
staticMethod:5
staticMethod:6
normalMethod:3
staticMethod:7
staticMethod:8
normalMethod:4
staticMethod:9
normalMethod:5
normalMethod:6
normalMethod:7
normalMethod:8
normalMethod:9

       那当我们想让所有这个类下面的对象都同步的时候，也就是让所有这个类下面的对象共用同一把锁的时候，我们如何办呢？

       法1：将normalMethod方法也改成static,这样这两个static方法都属于类方法，它们获取到的锁都是当前调用这个方法的对象所属的类(Class，而不再是由这个Class产生的某个具体对象了)。但这样会影响代码结构和对象的封装性。

       修改实例1如下：

package com.bijian.thread;

public class SynchronizedTest {
	public static synchronized void staticMethod() throws InterruptedException {
		for (int i = 0; i < 10; i++) {
			Thread.sleep(500);
			System.out.println("staticMethod:" + i);
		}
	}
	public static synchronized void normalMethod() throws InterruptedException {
		for (int i = 0; i < 10; i++) {
			Thread.sleep(1000);
			System.out.println("normalMethod:" + i);
		}
	}

	public static void main(String[] args) {
		Thread thread = new Thread(new Runnable() {
			public void run() {
				try {
					SynchronizedTest.normalMethod();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}, "a");
		
		Thread thread1 = new Thread(new Runnable() {
			public void run() {
				try {
					SynchronizedTest.staticMethod();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}, "b");

		thread1.start();
		thread.start();
	}
}

       运行结果：

staticMethod:0
staticMethod:1
staticMethod:2
staticMethod:3
staticMethod:4
staticMethod:5
staticMethod:6
staticMethod:7
staticMethod:8
staticMethod:9
normalMethod:0
normalMethod:1
normalMethod:2
normalMethod:3
normalMethod:4
normalMethod:5
normalMethod:6
normalMethod:7
normalMethod:8
normalMethod:9

       也许有人说：将实例1的staticMethod方法改成的static去掉也能达到目的。确实可以，因为非static方法获取到的锁，就是当前调用这个方法的对象的锁，而实例1只有一个SynchronizedTest实例，如再创建一个实例，则就有问题了。如下所示：

         

package com.bijian.thread;

public class SynchronizedTest {

	public synchronized void staticMethod() throws InterruptedException {
		for (int i = 0; i < 10; i++) {
			Thread.sleep(500);
			System.out.println("staticMethod:" + i);
		}
	}

	public synchronized void normalMethod() throws InterruptedException {
		for (int i = 0; i < 10; i++) {
			Thread.sleep(1000);
			System.out.println("normalMethod:" + i);
		}
	}

	public static void main(String[] args) {
		final SynchronizedTest synchronizedTest = new SynchronizedTest();
		Thread thread = new Thread(new Runnable() {
			public void run() {
				try {
					synchronizedTest.normalMethod();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}, "a");

		//为了验证获取到的锁都是当前调用这个方法的对象所属的类，特另新建一个对象
		final SynchronizedTest synchronizedTest2 = new SynchronizedTest();
		
		Thread thread1 = new Thread(new Runnable() {
			public void run() {
				try {
					synchronizedTest2.staticMethod();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}, "b");

		thread1.start();
		thread.start();
	}
}

       运行结果：

staticMethod:0
staticMethod:1
normalMethod:0
staticMethod:2
staticMethod:3
normalMethod:1
staticMethod:4
staticMethod:5
normalMethod:2
staticMethod:6
normalMethod:3
staticMethod:7
staticMethod:8
normalMethod:4
staticMethod:9
normalMethod:5
normalMethod:6
normalMethod:7
normalMethod:8
normalMethod:9

 

       法2：语句块锁，直接看如下实例：

       实例2：

package com.bijian.thread;

public class SynchronizedTest {

	public final static Byte[] locks = new Byte[0];  

	public static void staticMethod() throws InterruptedException {
		synchronized(locks) {
			for (int i = 0; i < 10; i++) {
				Thread.sleep(500);
				System.out.println("staticMethod:" + i);
			}
		}
	}

	public void normalMethod() throws InterruptedException {
		synchronized(locks) {
			for (int i = 0; i < 10; i++) {
				Thread.sleep(1000);
				System.out.println("normalMethod:" + i);
			}
		}
	}

	public static void main(String[] args) {
		final SynchronizedTest synchronizedTest = new SynchronizedTest();
		Thread thread = new Thread(new Runnable() {
			public void run() {
				try {
					synchronizedTest.normalMethod();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}, "a");

		Thread thread1 = new Thread(new Runnable() {
			public void run() {
				try {
					SynchronizedTest.staticMethod();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}, "b");

		thread1.start();
		thread.start();
	}
}

       运行结果：

staticMethod:0
staticMethod:1
staticMethod:2
staticMethod:3
staticMethod:4
staticMethod:5
staticMethod:6
staticMethod:7
staticMethod:8
staticMethod:9
normalMethod:0
normalMethod:1
normalMethod:2
normalMethod:3
normalMethod:4
normalMethod:5
normalMethod:6
normalMethod:7
normalMethod:8
normalMethod:9