Java关于Synchronized关键字在不同位置使用的理解

Java中的Synchronized关键字

可以用来修饰同步方法：

像这样synchronized void f() {/*body*/}

也可以修饰同步语句块：

像这样synchronized(object){/*body*/}。

其中修饰同步方法还可以分为修饰static方法和实例方法。

其中修饰同步语句块还可以分为修饰instance变量，Object Reference对象引用，class 字面常量。

当synchronized作用在方法上时，锁住的便是对象实例（this）；

所以synchronized void f() {/*body*/}和 void f(synchronized(this){/*body*/})是等价的。

当作用在静态方法时锁住的便是对象对应的Class实例，因为Class数据存在于永久带，因此静态方法锁相当于该类的一个全局锁；

当synchronized作用于某一个对象实例时，锁住的便是对应的代码块。

在HotSpot JVM实现中，锁有个专门的名字：对象监视器。

synchronized(class)
synchronized(this)
－＞线程各自获取monitor，不会有等待．

线程分别获取class和this，不会造成等待的例子：

package com.hyy.test;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SyncTest02 implements Runnable {

	private static boolean flag = true;

	private void testSync1() {
		synchronized (this) {
			for (int i = 0; i < 100; i++) {
				System.out.println("testSyncObject: " + i);
			}
		}
	}

	private void testSync2() {
		synchronized (SyncTest02.class) {
			for (int i = 0; i < 100; i++) {
				System.out.println("testSyncClass:" + i);
			}
		}
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub

		if (flag) {
			flag = false;
			testSync1();
		} else {
			flag = true;
			testSync2();
		}

	}

	public static void main(String[] args) {
		ExecutorService exec = Executors.newFixedThreadPool(2);
		SyncTest02 sy1 = new SyncTest02();
		SyncTest02 sy2 = new SyncTest02();

		exec.execute(sy1);
		exec.execute(sy2);
		exec.shutdown();
	}

}

synchronized(this)
synchronized(this)
－＞如果不同线程监视同一个实例对象，就会等待，如果不同的实例，不会等待．

不同线程监视同一个实例对象的例子：

package com.hyy.test;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SyncTest {

	public static void main(String[] args) {
		ExecutorService es = Executors.newFixedThreadPool(2);
		MyCount mc = new MyCount();
		MyThread mt1 = new MyThread(mc, "thread 1");
		MyThread mt2 = new MyThread(mc, "thread 2");
		es.execute(mt1);
		es.execute(mt2);
		es.shutdown();
	}

}

class MyThread extends Thread {

	MyCount count;
	String threadName;

	public MyThread(MyCount count, String threadName) {
		// TODO Auto-generated constructor stub
		this.count = count;
		this.threadName = threadName;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		for (int i = 0; i < 10; i++) {
			count.addOne(threadName);

			try {
				sleep(100L);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

}

class MyCount {
	int i;

	public void addOne(String threadName) {
		synchronized (this) {
			i++;
			System.out.println(threadName + ":" + i);
		}

	}
}

输出为

thread 1:1
thread 2:2
thread 1:3
thread 2:4
thread 2:5
thread 1:6
thread 2:7
thread 1:8
thread 1:9
thread 2:10
thread 1:11
thread 2:12
thread 2:13
thread 1:14
thread 1:15
thread 2:16
thread 1:17
thread 2:18
thread 1:19
thread 2:20

从输出上看，线程间出现了等待

不同线程监视不同实例对象的例子：

package com.hyy.test;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SyncTest {

	public static void main(String[] args) {
		ExecutorService es = Executors.newFixedThreadPool(2);
		MyCount mc = new MyCount("countONE");
		MyCount mc2 = new MyCount("countTWO");
		MyThread mt1 = new MyThread(mc, "thread 1");
		MyThread mt2 = new MyThread(mc2, "thread 2");
		es.execute(mt1);
		es.execute(mt2);
		es.shutdown();
	}

}

class MyThread extends Thread {

	MyCount count;
	String threadName;

	public MyThread(MyCount count, String threadName) {
		// TODO Auto-generated constructor stub
		this.count = count;
		this.threadName = threadName;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		for (int i = 0; i < 10; i++) {
			count.addOne(threadName);

			try {
				sleep(100L);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

}

class MyCount {
	
	int i;
	String countName;
	
	
	public MyCount(String countName) {
		// TODO Auto-generated constructor stub
		this.countName = countName;
	}
	

	public void addOne(String threadName) {
		synchronized (this) {
			i++;
			System.out.println(threadName +"&&"+countName+ ":" + i);
		}

	}
}

输出为

thread 2&&countTWO:1
thread 1&&countONE:1
thread 2&&countTWO:2
thread 1&&countONE:2
thread 2&&countTWO:3
thread 1&&countONE:3
thread 2&&countTWO:4
thread 1&&countONE:4
thread 1&&countONE:5
thread 2&&countTWO:5
thread 2&&countTWO:6
thread 1&&countONE:6
thread 2&&countTWO:7
thread 1&&countONE:7
thread 1&&countONE:8
thread 2&&countTWO:8
thread 2&&countTWO:9
thread 1&&countONE:9
thread 1&&countONE:10
thread 2&&countTWO:10

从输出上看，线程间没有发上等待。

synchronized(class)
synchronized(class)
－＞如果不同线程监视同一个实例或者不同的实例对象，都会等待．

不同线程监视不同实例对象的例子：

package com.hyy.test;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SyncTest02 implements Runnable {

	private static boolean flag = true;

	private void testSync1() {
		synchronized (SyncTest02.class) {
			for (int i = 0; i < 100; i++) {
				System.out.println("testSyncObject: " + i);
			}
		}
	}

	private void testSync2() {
		synchronized (SyncTest02.class) {
			for (int i = 0; i < 100; i++) {
				System.out.println("testSyncClass:" + i);
				
			}
		}
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub

		if (flag) {
			flag = false;
			testSync1();
		} else {
			flag = true;
			testSync2();
		}

	}

	public static void main(String[] args) {
		ExecutorService exec = Executors.newFixedThreadPool(2);
		SyncTest02 sy1 = new SyncTest02();
		SyncTest02 sy2 = new SyncTest02();

		exec.execute(sy1);
		exec.execute(sy2);
		exec.shutdown();
	}

}