查看原文
其他

【并发技术03】传统线程互斥技术—synchronized

倪升武 武哥聊编程 2022-08-24


在多个线程同时操作相同资源的时候,就会遇到并发的问题,如银行转账啊、售票系统啊等。为了避免这些问题的出现,我们可以使用 synchronized 关键字来解决,下面针对 synchronized 常见的用法做一个总结。首先写一个存在并发问题的程序,如下:

  1. public class TraditionalThreadSynchronized {

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

  3.        //在静态方法中不能new内部类的实例对象

  4.        //private Outputer outputer = new Outputer();

  5.        new TraditionalThreadSynchronized().init();

  6.    }

  7.    private void init() {

  8.        final Outputer outputer = new Outputer();

  9.        //线程1打印:duoxiancheng

  10.        new Thread(new Runnable() {        

  11.            @Override

  12.            public void run() {

  13.                while(true) {

  14.                    try {

  15.                        Thread.sleep(5);

  16.                    } catch (InterruptedException e) {

  17.                        // TODO Auto-generated catch block

  18.                        e.printStackTrace();

  19.                    }

  20.                    outputer.output1("duoxiancheng");

  21.                }

  22.            }

  23.        }).start();;

  24.        //线程2打印:eson15

  25.        new Thread(new Runnable() {        

  26.            @Override

  27.            public void run() {

  28.                while(true) {

  29.                    try {

  30.                        Thread.sleep(5);

  31.                    } catch (InterruptedException e) {

  32.                        // TODO Auto-generated catch block

  33.                        e.printStackTrace();

  34.                    }

  35.                    outputer.output1("eson15");

  36.                }

  37.            }

  38.        }).start();;

  39.    }

  40.    static class Outputer {

  41.        //自定义一个字符串打印方法,一个个字符的打印

  42.        public void output1(String name) {

  43.            int len = name.length();

  44.            for(int i = 0; i < len; i++) {

  45.                System.out.print(name.charAt(i));

  46.            }

  47.            System.out.println("");    

  48.        }      

  49.    }

  50. }

在内部类 Outputer 中定义了一个打印字符串的方法,一个字符一个字符的打印,这样比较容易直观的看出并发问题,因为字符顺序打乱了就说明出现问题了。然后在 init 方法中开启两个线程,一个线程打印 “duoxiancheng” ,另一个线程打印 “eson15”。看一下运行结果:

eson15duoxianche
ng
eson15
duoxiancheng
duoxiancheng
eson15
esduoxiancheng
on15
duoxiancheng

从输出的结果中可以看到,已经出现问题了,为了解决这个问题,可以使用 synchronized 同步代码块来对公共部分进行同步操作,但是需要给它一把锁,这把锁是一个对象,可以是任意一个对象,但是前提是,两个线程使用的必须是同一个对象锁才可以,这很好理解。那么下面在 output1() 方法中加入 synchronized 代码块:

  1. static class Outputer {

  2.    private String token = ""; //定义一个锁

  3.    public void output1(String name) {

  4.        synchronized(token) //任何一个对象都可以作为参数,但是该对象对于两个线程来说是同一个才行

  5.        //如果用name就不行了,因为不同的线程进来name是不一样的,不是同一个name

  6.        {

  7.            int len = name.length();

  8.            for(int i = 0; i < len; i++) {

  9.                System.out.print(name.charAt(i));

  10.            }

  11.            System.out.println("");    

  12.        }

  13.    }

  14. }    

经过上面的改造,线程安全问题就基本解决了,但是还可以再往下引申,如果在方法上加 synchronized 关键字的话,那么这个同步锁是什么呢?我们在 Outputer 类中再写一个 output2() 方法:

  1. static class Outputer {

  2.    private String token = ""; //定义一个锁

  3.    public void output1(String name) {

  4.        synchronized(token) //任何一个对象都可以作为参数,但是该对象对于两个线程来说是同一个才行

  5.        {

  6.            int len = name.length();

  7.            for(int i = 0; i < len; i++) {

  8.                System.out.print(name.charAt(i));

  9.            }

  10.            System.out.println("");    

  11.        }

  12.    }  

  13.    public synchronized void output2(String name) {

  14.        int len = name.length();

  15.        for(int i = 0; i < len; i++) {

  16.            System.out.print(name.charAt(i));

  17.        }

  18.        System.out.println("");    

  19.    }  

  20. }

方法内部实现逻辑一模一样,唯一不同的就是 synchronized 加在了方法上,那么我们让 init() 方法中的两个线程中,一个调用 output1(Stringname) 方法,另一个调用 output2(Stringname) 方法,从结果中能看出,线程安全问题又出现了。产生问题的原因不难发现:现在两个方法都加了 synchronized,但是两个线程在调用两个不同的方法还是出现了问题,也就是说,还是各玩各的……那么问题就出在这个锁上,说明两者并没有使用同一把锁!
如果我们把 output1() 方法中 synchronized 中的 token 改成 this,再运行就没问题了,这说明一点:synchronized 关键字修饰方法的时候,同步锁是 this,即等效于代码块 synchronized(this){...}
再继续往下引申,现在在 Outputer 类中再写一个静态方法 output3(Stringname),并且也让 synchronized 去修饰这个静态方法。

  1. static class Outputer {

  2.    private String token = ""; //定义一个锁

  3.    public void output1(String name) {

  4.        synchronized(token) //任何一个对象都可以作为参数,但是该对象对于两个线程来说是同一个才行

  5.        {

  6.            int len = name.length();

  7.            for(int i = 0; i < len; i++) {

  8.                System.out.print(name.charAt(i));

  9.            }

  10.            System.out.println("");    

  11.        }

  12.    }  

  13.    public static synchronized void output3(String name) {

  14.        int len = name.length();

  15.        for(int i = 0; i < len; i++) {

  16.            System.out.print(name.charAt(i));

  17.        }

  18.        System.out.println("");    

  19.        }  

  20.    }

  21. }

然后在 init() 方法中一个线程调用 output1() 方法,另一个线程调用 output3() 方法。毫无疑问,肯定又会出现线程安全问题。但是如何解决呢?因为 static 方法在类加载的时候就加载了,所以这个锁应该是类的字节码对象。那么将 token 改为 Outputer.class 就解决问题了,这说明一点:synchronized 关键字修饰 static 方法的时候,同步锁是该类的字节码对象,即等效于代码块 synchronized(classname.class){...}
最后再总结一下:

  • 同步代码块的锁是任意对象。只要不同的线程都执行同一个同步代码块的时候,这个锁随便设。

  • 同步函数的锁是固定的 this。当需要和同步函数中的逻辑实行同步的时候,代码块中的锁必须为 this。

  • 静态同步函数的锁是该函数所属类的字节码文件对象。该对象可以用 this.getClass() 方法获取,也可以使用 当前类名.class 表示。


如果觉得对您有帮助,转发给更多人吧~



您可能也对以下帖子感兴趣

文章有问题?点此查看未经处理的缓存