每天一例多线程[day2]-----synchronized与多个线程多个锁

 

package com.jeff.base.sync002;

1. /**

2. * 多个线程多个锁

3. *

4. * 关键字synchronized取得的锁都是对象锁，而不是把一段代码（方法）当做锁，

5. * 所以代码中哪个线程先执行synchronized关键字的方法，哪个线程就持有该方法所属对象的锁（Lock），

6. *

7. * @author jeff

8. *

9. */

10. public class MultiThread {

11.  

12. private static int num = 0;

13.  

14. /** static */

15. public static synchronized void printNum(String tag){

16. try {

17. if(tag.equals("a")){

18. num = 100;

19. System.out.println("tag a, set num over!");

20. Thread.sleep(1000);

21. } else {

22. num = 200;

23. System.out.println("tag b, set num over!");

24. }

25.  

26. System.out.println("tag " + tag + ", num = " + num);

27.  

28. } catch (InterruptedException e) {

29. e.printStackTrace();

30. }

31. }

32.  

33. //注意观察run方法输出顺序

34. public static void main(String[] args) {

35.  

36. /**

37. * 俩个不同的对象m1/m2：

38. * 一个对象一把锁，m1和m2两个对象获得的是自己的那一把对象锁 ，两者没有任何关系，不存在同步问题。

39. *

40. * 在静态类型的printNum方法上加synchronized关键字，表示锁定.class类，类一级别的锁（独占.class类）。

41. * m1和m2两个线程对象在访问printNum时，访问的是同一把锁，

42. * 所以最终的结果一定是：要么先执行a的结果，再执行b的：

43. * tag a, set num over!

44. tag a, num = 100

45. tag b, set num over!

46. tag b, num = 200

47. 要么是先执行b的，再执行a的：

48. tag b, set num over!

49. tag b, num = 100

50. tag a, set num over!

51. tag a, num = 200

52. *

53. */

54. final MultiThread m1 = new MultiThread();

55. final MultiThread m2 = new MultiThread();

56.  

57. Thread t1 = new Thread(new Runnable() {

58. @Override

59. public void run() {

60. m1.printNum("a");

61. }

62. });

63.  

64. Thread t2 = new Thread(new Runnable() {

65. @Override

66. public void run() {

67. m2.printNum("b");

68. }

69. });

70.  

71. t1.start();

72. t2.start();

73.  

74. }

75. }

如果把printNum方法的static关键词去掉，打印的结果：

1. tag a, set num over!

2. tag b, set num over!

3. tag b, num = 200

4. tag a, num = 200

也就是说，这两个线程之间获得的是自己的那一把锁，多个线程多个锁，各自无影响。