Java线程安全之同步方法

同步方法

使用synchronized修饰的方法，就叫做同步方法，其固定格式如下：

1. public [static] synchronized 返回值类型 同步方法() {
2.         可能会产生线程安全问题的代码
3. }

复制代码

留意事项：

• 同步方法可以是平凡成员方法，也可以是static静态方法
  
• 平凡成员同步方法，默认锁对象为this，即当火线法的调用对象
  
• static静态同步方法，默认锁对象是当前类的字节码对象（一个类有且只有一个）
  

   类的字节码对象：类名.class，固定用法（当前记取即可，后续反射章节会学习）
  案例1：平凡同步方法
​ 创建子线程1，调用100次平凡方法print1（逐字输出 “好好学习”）
​ 创建子线程2，调用100次平凡方法print2（逐字输出 “天天向上”）
​ 要求，两个子线程在执行方法的过程中，不会被另一个线程打断。

1. class Printer {
2.         //普通同步方法: 锁对象默认为this
3.         public synchronized void print1() {
4.                 System.out.print("天");
5.                 System.out.print("天");
6.                 System.out.print("向");
7.                 System.out.print("上");
8.                 System.out.println();
9.         }
10.        
11.         public void print2() {       
12.         //同步代码块，也使用this作为锁对象
13.         //测试时，可以注释同步代码块，或使用其他锁对象，然后观察程序运行效果
14.                 //synchronized (Printer.class) {
15.         synchronized (this) {
16.                         System.out.print("努");
17.                         System.out.print("力");
18.                         System.out.print("学");
19.                         System.out.print("习");
20.                         System.out.println();
21.                 }
22.         }
23. }
25. public class Test16_Funtion {
26.         public static void main(String[] args) {
27.                 //准备一个对象
28.                 final Printer p = new Printer();
29.                
30.                 //创建子线程1，输出100次 "好好学习"
31.                 Thread th1 = new Thread() {
32.                         @Override
33.                         public void run() {
34.                                 for(int i = 0; i < 100; i++)
35.                                         p.print1();
36.                         }
37.                 };
38.                
39.                 //创建子线程2，输出100次 "天天向上"
40.                 Thread th2 = new Thread() {
41.                         @Override
42.                         public void run() {
43.                                 for(int i = 0; i < 100; i++)
44.                                         p.print2();
45.                         }
46.                 };
47.                
48.                 th1.start();
49.                 th2.start();
50.         }
51. }

复制代码

测试结果：

• print2方法不使用同步代码块，或不使用this作为锁对象，会出现输出杂乱的情况，线程没有实现同步（上锁失败）
  

• print2方法使用同步代码块，且用this作为锁对象，成功实现线程同步
  

案例2：静态同步方法
​ 将上述案例中的平凡同步方法，修改为静态同步方法，实现原有功能。

1. class Printer {
2.     // ...省略print1() print2()
3.    
4.         //static静态同步方法: 锁对象默认为当前类字节码对象
5.         public static synchronized void print3() {
6.                 System.out.print("天");
7.                 System.out.print("天");
8.                 System.out.print("向");
9.                 System.out.print("上");
10.                 System.out.println();
11.         }
12.        
13.         public void print4() {       
14.         //同步代码块，使用当前类字节码对象作为锁对象
15.         
16.         //注释掉同步代码块，运行测试，观察效果
17.         //不使用当前类字节码对象作为锁对象，运行测试，观察效果
18.         //synchronized (this) {
19.                 synchronized (Printer.class) {
20.                         System.out.print("努");
21.                         System.out.print("力");
22.                         System.out.print("学");
23.                         System.out.print("习");
24.                         System.out.println();
25.                 }
26.         }
27. }
29. public class Test16_Funtion {
30.         public static void main(String[] args) {
31.                 //准备一个对象
32.                 final Printer p = new Printer();
33.                
34.                 //创建子线程1，输出100次 "好好学习"
35.                 Thread th1 = new Thread() {
36.                         @Override
37.                         public void run() {
38.                                 for(int i = 0; i < 100; i++)
39.                                         Printer.print3();
40.                         }
41.                 };
42.                
43.                 //创建子线程2，输出100次 "天天向上"
44.                 Thread th2 = new Thread() {
45.                         @Override
46.                         public void run() {
47.                                 for(int i = 0; i < 100; i++)
48.                                         p.print4();
49.                         }
50.                 };
51.                
52.                 th1.start();
53.                 th2.start();
54.         }
55. }

复制代码

运行测试：
​ 按照print4方法中形貌进行测试，验证结论：
   static静态同步方法: 锁对象默认为当前类字节码对象（类名.class）
  线程状态图为：

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。