Java类锁和对象锁实践

类锁和对象锁是否会冲突？对象锁和私有锁是否会冲突？通过实例来进行说明。

一、相关约定

为了明确后文的描述，先对本文涉及到的锁的相关定义作如下约定：

1. 类锁：在代码中的方法上加了static和synchronized的锁，或者synchronized(xxx.class）的代码段，如下文中的increament()；

2.对象锁：在代码中的方法上加了synchronized的锁，或者synchronized(this）的代码段，如下文中的synOnMethod()和synInMethod()；

3.私有锁：在类内部声明一个私有属性如private Object lock，在需要加锁的代码段synchronized(lock），如下文中的synMethodWithObj()。

 

二、测试代码

1.编写一个启动类ObjectLock

01	public class ObjectLock {

02	public static void main(String[] args) {

03	System.out.println("start time = " + System.currentTimeMillis()+"ms");

04	LockTestClass test = new LockTestClass();

05	for (int i = 0; i < 3; i++) {

06	Thread thread = new ObjThread(test, i);

07	thread.start();

08

}

09

}

10

}

2.编写一个线程类ObjThread，用于启动同步方法（注意它的run方法可能会调整以进行不同的测试）

01	public class ObjThread extends Thread {

02	LockTestClass lock;

03	int i = 0;

04

05	public ObjThread(LockTestClass lock, int i) {

06	this.lock = lock;

07	this.i = i;

08

}

09

10	public void run() {

11

//无锁方法

12	//      lock.noSynMethod(this.getId(),this);

13	//对象锁方法1，采用synchronized synInMethod的方式

14	lock.synInMethod();

15	//对象锁方法2，采用synchronized(this)的方式

16	//      lock.synOnMethod();

17	//私有锁方法，采用synchronized(object)的方式

18	//      lock.synMethodWithObj();

19	//类锁方法，采用static synchronized increment的方式

20	LockTestClass.increment();

21

}

22

}

3.再编写一个锁的测试类LockTestClass，包括各种加锁方法

01	public class LockTestClass {

02

//用于类锁计数

03	private static int i = 0;

04

//私有锁

05	private Object object = new Object();

06

07

/**

08	* <p>

09

* 无锁方法

10

*

11	* @param threadID

12	* @param thread

13

*/

14	public void noSynMethod(long threadID, ObjThread thread) {

15	System.out.println("nosyn: class obj is " + thread + ", threadId is"

16	+ threadID);

17

}

18

19

/**

20

* 对象锁方法1

21

*/

22	public synchronized void synOnMethod() {

23	System.out.println("synOnMethod begins" + ", time = "

24	+ System.currentTimeMillis() + "ms");

25

try {

26	Thread.sleep(2000L);

27	} catch (InterruptedException e) {

28	e.printStackTrace();

29

}

30	System.out.println("synOnMethod ends");

31

}

32

33

/**

34	* 对象锁方法2,采用synchronized (this)来加锁

35

*/

36	public void synInMethod() {

37	synchronized (this) {

38	System.out.println("synInMethod begins" + ", time = "

39	+ System.currentTimeMillis() + "ms");

40

try {

41	Thread.sleep(2000L);

42	} catch (InterruptedException e) {

43	e.printStackTrace();

44

}

45	System.out.println("synInMethod ends");

46

}

47

48

}

49

50

/**

51

* 对象锁方法3

52

*/

53	public void synMethodWithObj() {

54	synchronized (object) {

55	System.out.println("synMethodWithObj begins" + ", time = "

56	+ System.currentTimeMillis() + "ms");

57

try {

58	Thread.sleep(2000L);

59	} catch (InterruptedException e) {

60	e.printStackTrace();

61

}

62	System.out.println("synMethodWithObj ends");

63

}

64

}

65

66

/**

67

* 类锁

68

*/

69	public static synchronized void increament() {

70	System.out.println("class synchronized. i = " + i + ", time = "

71	+ System.currentTimeMillis() + "ms");

72

i++;

73

try {

74	Thread.sleep(2000L);

75	} catch (InterruptedException e) {

76	e.printStackTrace();

77

}

78	System.out.println("class synchronized ends.");

79

}

80

81

}

三、测试结果

1.测试类锁和对象锁，ObjectThread的run方法修改如下：

01	public void run() {

02

//无锁方法

03	//      lock.noSynMethod(this.getId(),this);

04	//对象锁方法1，采用synchronized synInMethod的方式

05	lock.synInMethod();

06	//对象锁方法2，采用synchronized(this)的方式

07	//      lock.synOnMethod();

08	//私有锁方法，采用synchronized(object)的方式

09	//      lock.synMethodWithObj();

10	//类锁方法，采用static synchronized increment的方式

11	LockTestClass.increament();

12

}

终端输出：

start time = 1413101360231ms
synInMethod begins, time = 1413101360233ms
synInMethod ends
class synchronized. i = 0, time = 1413101362233ms
synInMethod begins, time = 1413101362233ms
class synchronized ends.
synInMethod ends
class synchronized. i = 1, time = 1413101364233ms
synInMethod begins, time = 1413101364233ms
class synchronized ends.
synInMethod ends
class synchronized. i = 2, time = 1413101366234ms
class synchronized ends.

可以看到对象锁方法(synInMothod）第一次启动时比类锁方法（increament)快2秒，这是因为在synInMehtod执行时 sleep了2秒再执行的increament，而这两个方法共用一个线程，所以会慢2秒，如果increament在run中放到 synInMethod前面，那么第一次启动时就是increament快2秒。
而当类锁方法启动时，另一个线程时的对象锁方法也几乎同时启动，说明二者使用的并非同一个锁，不会产生竞争。
结论：类锁和对象锁不会产生竞争，二者的加锁方法不会相互影响。

2.私有锁和对象锁，ObjectThread的run方法修改如下：

01	public void run() {

02

//无锁方法

03	//      lock.noSynMethod(this.getId(),this);

04	//对象锁方法1，采用synchronized synInMethod的方式

05	lock.synInMethod();

06	//对象锁方法2，采用synchronized(this)的方式

07	//      lock.synOnMethod();

08	//私有锁方法，采用synchronized(object)的方式

09	lock.synMethodWithObj();

10	//类锁方法，采用static synchronized increment的方式

11	//      LockTestClass.increament();

12

}

终端输出：

start time = 1413121912406ms
synInMethod begins, time = 1413121912407ms.
synInMethod ends.
synMethodWithObj begins, time = 1413121914407ms
synInMethod begins, time = 1413121914407ms.
synInMethod ends.
synMethodWithObj ends
synInMethod begins, time = 1413121916407ms.
synMethodWithObj begins, time = 1413121916407ms
synInMethod ends.
synMethodWithObj ends
synMethodWithObj begins, time = 1413121918407ms
synMethodWithObj ends

和类锁和对象锁非常类似。

结论：私有锁和对象锁也不会产生竞争，二者的加锁方法不会相互影响。

3.synchronized直接加在方法上和synchronized(this)，ObjectThread的run方法修改如下：

public void run() {
		//无锁方法
//		lock.noSynMethod(this.getId(),this);
		//对象锁方法1，采用synchronized synInMethod的方式
		lock.synInMethod();
		//对象锁方法2，采用synchronized(this)的方式
		lock.synOnMethod();
		//私有锁方法，采用synchronized(object)的方式
//		lock.synMethodWithObj();
		//类锁方法，采用static synchronized increment的方式
//		LockTestClass.increament();
	}

终端输出：

start time = 1413102913278ms
synInMethod begins, time = 1413102913279ms
synInMethod ends
synInMethod begins, time = 1413102915279ms
synInMethod ends
synOnMethod begins, time = 1413102917279ms
synOnMethod ends
synInMethod begins, time = 1413102919279ms
synInMethod ends
synOnMethod begins, time = 1413102921279ms
synOnMethod ends
synOnMethod begins, time = 1413102923279ms
synOnMethod ends

       可以看到，二者严格地串行输出（当然再次执行时先运行synInMethod还是先运行synOnMethod并不是确定的，取决于谁获得了锁）。

    结论：synchronized直接加在方法上和synchronized(this)都是对当前对象加锁，二者的加锁方法够成了竞争关系，同一时刻只能有一个方法能执行。