每天一例多线程[day3]-----synchronized与一个对象多个方法一把锁

 

1. package com.jeff.base.sync003;

2.  

3. /**

4. * 一个对象多个方法一把锁

5. *

6. * 对象锁的同步和异步问题

7.  

8. * @author jeff

9. *

10. */

11. public class MyObject {

12.  

13. /**

14. * 同步方法

15. */

16. public synchronized void method1(){

17. try {

18. System.out.println(Thread.currentThread().getName());

19. Thread.sleep(4000);

20. } catch (InterruptedException e) {

21. e.printStackTrace();

22. }

23. }

24.  

25. /**

26. * 异步方法

27. * */

28. public synchronized void method2(){

29. System.out.println(Thread.currentThread().getName());

30. }

31.  

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

33.  

34. final MyObject mo = new MyObject();

35.  

36. /**

37. * 分析：

38. * t1线程先持有mo对象的Lock锁，t2线程可以以异步的方式调用mo中的非synchronized修饰的方法，所以两个方法几乎同时执行打印结果。

39. *

40. * t1线程先持有mo对象的Lock锁，t2线程如果在这个时候调用mo中的同步（synchronized）方法则需等待t1释放mo对象锁后才能执行method2同步方法打印结果。

41. */

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

43. @Override

44. public void run() {

45. mo.method1();

46. }

47. },"t1");

48.  

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

50. @Override

51. public void run() {

52. mo.method2();

53. }

54. },"t2");

55.  

56. t1.start();

57. t2.start();

58.  

59. }

60.  

61. }

打印结果：

1. t1

2. t2

 但是t2是在t1打印4s钟以后打印。原因就是t1和t2两个线程执行是同一个对象的不同方法，且这两个方法都加了对象锁synchronized,导致只有当一个线程释放锁后，另外一个线程才能执行，当t1获得锁后，进入方法打印t1，休眠4s，释放锁，t2之后获得锁，打印t2.

 

注意两个概念：

1 同步方法：加了synchronized的方法，存在锁竞争。

2 异步方法：不加synchronized的方法，不存在锁竞争。

 

如果我们把method2的synchronized去掉，打印结果依然是t1和t2，不同的是两者几乎是同时打印，不存在像同步一样的先后顺序。