synchronized到底锁了什么(一)

synchronized关键字,需要编写多线程代码的java开发者经常会用到的关键字,它的主要作用是使方法同步,本文将通过一系列测试,希望可以深入解此关键字.
一.synchronized的使用方法.
开始之前,先要搞清楚synchronized字段的使用方法
1.synchronized可以用来声明成员方法,

public synchronized int method () {

}

2.synchronized可以用在代码块中,例如

public void method {
    synchronized(this) {
        dosth();
    }
}

注,括号里必须是一个实例

二.synchronized的作用
下面将开始具体的测试,这次主要测试将synchronized用于声明方法时的主要作用.下面的TestBean.java,这是用户测试的主体类,测试将围绕此类逐步进行.

package org.sluggard.bolg.synctest;

/**
 * 此类为测试的主体类,其中声明了2个动态的同步方法,
 * 2个静态的同步方法,1个动态的非同步方法和1个静态的非同步方法,所有命名为A的方法,
 * 进入方法后会sleep10秒,所有B方法,将只sleep1秒,而所有的非同步方法,将sleep5秒.
 * @author Frank
 *
 */
public class TestBean {
	
	private String dynamicField;
	
	private static String staticField;
	
	/**
	 * 动态的同步方法A
	 * @param value
	 */
	public synchronized void dynamicSyncMethodA(String value) {
		System.out.println("I'm synchronized methodA");
		SleepUtil.sleep(10);
		dynamicField = value;
		System.out.println("Now field is : " + dynamicField);
	}
	
	/**
	 * 动态的同步方法B
	 */
	public synchronized void dynamicSyncMethodB(String value) {
		System.out.println("I'm synchronized methodB");
		SleepUtil.sleep(1);
		dynamicField = value;
		System.out.println("Now field is : " + dynamicField);
	}
	
	/**
	 * 静态同步方法A
	 */
	public static synchronized void staticSyncMethodA(String value) {
		System.out.println("I'm static synchronized methodA");
		SleepUtil.sleep(10);
		staticField = value;
		System.out.println("Now field is : " + staticField);
	}
	
	/**
	 * 静态同步方法B
	 */
	public static synchronized void staticSyncMethodB(String value) {
		System.out.println("I'm static synchronized methodB");
		SleepUtil.sleep(1);
		staticField = value;
		System.out.println("Now field is : " + staticField);
	}
	
	/**
	 * 动态非同步方法
	 */
	public void dynamicUnsyncMethod(String value) {
		System.out.println("I'm dynamic unsynchronized method");
		SleepUtil.sleep(5);
		dynamicField = value;
		System.out.println("Now field is : " + dynamicField);
	}
	
	/**
	 * 静态非同步方法
	 */
	public static void staticUnsyncMethod(String value) {
		System.out.println("I'm static unsynchronized method");
		SleepUtil.sleep(5);
		staticField = value;
		System.out.println("Now field is : " + staticField);
	}
	
}

abstract class SleepUtil {
	public static void sleep(int i){
		try {
			Thread.sleep(i*1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

下面将针对此类编写测试代码,我们将解决一下一系列问题.
1,synchronized会所住整个类吗?
Test.java,我们为动态方法A和动态方法B分别编写了2个线程类,并分别对2个执行2个实例的synchronized方法.

package org.sluggard.bolg.synctest;

public class Test {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		TestBean testBean1 = new TestBean();
		TestBean testBean2 = new TestBean();
		ThreadDSA dsa = new ThreadDSA(testBean1);
		ThreadDSB dsb = new ThreadDSB(testBean2);
		dsa.start();
		SleepUtil.sleep(1);
		dsb.start();
	}

}

class ThreadDSA extends Thread{

	@Override
	public void run() {
		testBean.dynamicSyncMethodA("DSA");
	}
	
	private TestBean testBean;

	public ThreadDSA(TestBean testBean) {
		super();
		this.testBean = testBean;
	}
}

class ThreadDSB extends Thread{

	@Override
	public void run() {
		testBean.dynamicSyncMethodB("DSB");
	}
	
	private TestBean testBean;
	
	public ThreadDSB(TestBean testBean) {
		super();
		this.testBean = testBean;
	}
}

执行结果如下

引用

I'm synchronized methodA
I'm synchronized methodB
Now field is : DSB
Now field is : DSA

然后,我们将main方法进行修改,改成下面的样子

public static void main(String[] args) {
		
		TestBean testBean = new TestBean();
		ThreadDSA dsa = new ThreadDSA(testBean);
		ThreadDSB dsb = new ThreadDSB(testBean);
		dsa.start();
		SleepUtil.sleep(1);
		dsb.start();
	}

执行结果如下

引用

I'm synchronized methodA
Now field is : DSA
I'm synchronized methodB
Now field is : DSB

答案:synchronized并没有锁住整个类,而是仅仅锁住了某个实例,不同实例中的动态同步方法是不会同步的.
2.当程序进入synchronized方法后,非同步方法可以执行吗?
我们在Test.java中为非同步方法加入一个线程类

class ThreadDUS extends Thread{

	@Override
	public void run() {
		testBean.dynamicUnsyncMethod("DUS");
	}
	
	private TestBean testBean;
	
	public ThreadDUS(TestBean testBean) {
		super();
		this.testBean = testBean;
	}
}

对main方法进行修改

public static void main(String[] args) {
		
		TestBean testBean = new TestBean();
		ThreadDSA dsa = new ThreadDSA(testBean);
		ThreadDUS dus = new ThreadDUS(testBean);
		dsa.start();
		SleepUtil.sleep(1);
		dus.start();
	}

执行结果如下

引用

I'm synchronized methodA
I'm dynamic unsynchronized method
Now field is : DUS
Now field is : DSA

答案:同步锁不会所住非同步的方法,如果你希望2个方法顺序执行,就必须对他们的都枷锁.
3.synchronized会同时锁住动态方法和静态方法吗?
首先,我们先修改一下TestBean,在动态方法中加入对静态成员变量的操作

public synchronized void dynamicSyncMethodA(String value) {
		System.out.println("I'm synchronized methodA");
		SleepUtil.sleep(10);
		dynamicField = value;
		staticField = value;
		System.out.println("Now dynamicfield is : " + dynamicField + "\nNow staticfield is : " + value);
	}

同样,我们为静态同步方法加入线程类,

class ThreadSSA extends Thread{

	@Override
	public void run() {
		TestBean.staticSyncMethodA("SSA");
	}
	
}
class ThreadSSB extends Thread{

	@Override
	public void run() {
		TestBean.staticSyncMethodB("SSB");
	}
	
}

然后修改main方法

public static void main(String[] args) {
		
		TestBean testBean = new TestBean();
		ThreadDSA dsa = new ThreadDSA(testBean);
		ThreadSSB ssb = new ThreadSSB();
		ThreadSSA ssa = new ThreadSSA();
		dsa.start();
		SleepUtil.sleep(1);
		ssb.start();
		ssa.start();
	}

执行结果如下

引用

I'm static synchronized methodB
Now field is : SSB
I'm static synchronized methodA
Now dynamicfield is : DSA
Now staticfield is : DSA
Now field is : SSA

答案:静态方法和动态方法的锁是不同的,动态方法只与动态方法同步,静态方法只与静态方法同步.
三,总结,在动态方法声明中加入synchronized字段,方法将会在运行时获得此对象实例的锁,此实例的所有synchronized方法在锁为释放前将不无法执行,但是其他实例,此实例的非同步方法和静态方法将不受影响.一个类的所有静态方法共享同一把锁.
这是本系列文章的第一篇,主要说明在同一个类中,在声明方法时加入synchronized关键字的作用,以后的文章中,会对synchronized的其他用法,以及多个类之间synchronized关键字的作用进行测试.