探讨多线程环境下的并发安全性问题及常见解决方法

前言

上篇我们介绍了线程的创建、操作和状态等内容。我们通过下面代码来回顾一下

public class Demo11 {
    private static int count=0;
    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(()->{
            for(int i=0;i<50000;i++){
                count++;
            }
            System.out.println("t1线程结束");
        });
        Thread t2=new Thread(()->{
            for(int i=0;i<50000;i++){
                count++;
            }
            System.out.println("t2线程结束");
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("目标是100000，实际是： "+ count);
    }
}

        我们创建两个线程对象t1和t2,又定义一个成员变量count,并初始化为0，我们想通过这两个线程各自通过for循环50000次使count自增至100000，调用join()方法使主线程阻塞等待t1,t2线程结束之后打印出count的值，当我们运行后，可发现：

         我们运行多次结果都不是目标值 ，很显然此段代码是有bug的，我们还记得线程是并发执行的，调度是随机的~,若我们将t1和t2进行串行执行

我们仅仅更改join方法的位置，使得t1线程执行完毕，t2线程才开始，运行发现，结果对了！ 

        显而易见，当前bug是由于多线程并发执行代码引起的bug，这样的bug我们叫做“线程安全问题”（线程不安全）；反之一段代码，在多线程并发执行的环境下不会出现上述bug，我们叫做“线程安全”。

---

一、线程安全

1、概念

        线程安全是指在多线程环境下，程序能够保持预期的行为，而不会发生数据竞争、死锁等问题，那么可以说这个程序是线程安全的

2、线程不安全的原因

        （1）线程是随机调度，抢占式执行的（根本原因）

        （2）资源共享：多个线程同时访问共享的资源，可能会同时修改同一个变量

        （3）修改操作不是原子性的

        （4）内存可见性

        （5）指令重排序

        对于原因1：是操作系统的底层设计，我们干预不了~；原因2：我们可通过调整代码结构，避免让多个线程同时修改一个变量，但是我们有些场景无法避免此等情况；那么我们来看原因3：

2.1、原子性原因

       原子性是指一个操作要么全部执行成功，要么完全不执行，不存在执行一半这种情况。

        接前言代码，我们在两个线程中分别进行了count++；此操作并非只是一段简单的代码，其实内藏玄机——对应着CPU上的三个指令“Load”、“Add” 和 “Save”下图是对应的一种情况：

二、解决线程安全方法

1、synchronized关键字  

1.1、特性——互斥

         当一个方法或者代码块被用synchronized关键字修饰时，同一时刻只有一个线程能够访问该方法或者代码块，其他线程需要等待当前线程执行完毕后才能进行访问。

        进入synchronized修饰的代码快相当于加锁，退出该代码快相当于解锁。

public class Demo6 {
    public static int count=0;
    public static void main(String[] args) throws InterruptedException {
        Object lock=new Object(); //锁
        Thread t1=new Thread(() -> {
           for(int i=0;i<50000;i++) {
               synchronized(lock){
                   count++;
               }
           }
            System.out.println("t1执行完毕");
        });
        Thread t2=new Thread(()->{
           for(int i=0;i<50000;i++) {
               synchronized(lock){
                   count++;
               }
           }
            System.out.println("t2执行完毕");
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("目标是100000，实际是： "+ count);
    }
}

        此时CPU上的三个指令将会被作为一个不可分割的操作来执行，其他线程无法在这个操作过程中插入和调度，确保了操作的完整性和一致性。

1.2、特性——可重入性

此情况针对于以下死锁情况

public class Demo14 {
    private static int count=0;
    public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(()->{
            for (int i = 0; i < 50000; i++) {
                synchronized (Demo14.class){
                    synchronized (Demo14.class){
                        count++;
                    }
                }
            }
        });
        t.start();
        t.join();
    }
}

        我们在线程t中对于count++操作上了两把锁，锁对象为同一类对象，那么会不会造成自己把自己锁住的情况?(相当于把钥匙锁家里了，没钥匙解锁，我们该如何回家？？？)

        事实并非如此... 如果一个线程已经获得了某个对象的锁，在进入该对象的同步块时可以再次获得该对象的锁，而不会被阻塞。这样可以避免出现自己锁死自己的情况。也就是对于相同对象的锁，是可以继续往下执行的，而不是在原地阻塞等待！

可重入锁的内部包含“计数器”和“线程持有者”两个信息，在可重入锁在，每个锁对象会记录当前持有该锁的线程，即“线程持有者”，当一个线程尝试获取该锁时，首先检查是否已被其他线程持有，如果持有者是自己，则可以获取成功，且计数器递增；相应地，线程解锁时计数器递减。只有当计数器递减为零时，锁才会被真正释放，其他线程才能获取到这个锁。

        当使用synchronized关键字修饰一个方法时，锁住的是该方法所属对象实例；当使用synchronized关键字修饰一个代码块时，锁住的是指定的对象。 

2、volatile关键字

volatile修饰的变量，能够保证“内容可见性”，如下代码：

public class Demo15 {
    private static int count=0;
    public static void main(String[] args) {
        Thread t1=new Thread(()->{
            while(count==0){
                //do somoething
            }
            System.out.println("t1线程执行结束");
        });
        Thread t2=new Thread(()->{
            Scanner sc=new Scanner(System.in);
            System.out.println("请输入count的值使得t1线程结束");
            count=sc.nextInt();
        });
        t1.start();
        t2.start();
    }
}

        定义两个线程，t1线程在未输入改变变量count之前一直执行死循环，t2线程输入count的值，使t1线程执行一段时间后结束，但当我们输入count的值后，会发现一直未输出“t1线程执行结束”，打开jconsole后可发现t1线程状态为RUNNABLE，即一直运行状态。

 

         这是为什么呢？为什么t2线程对变量进行了修改，而t1线程却感受不到变量的改变呢，这就是编译器优化，在我们输入count的值之前，t1已经执行了很多次while条件判断，在此过程中，Java虚拟机（JVM）发现不管执行多少次，即线程反复将count从内存中读取值寄存器，再从寄存器上读取值，count的值始终为0，干脆就不再读取内存，直接从寄存器上读取count的值，这样一来，我们在t2线程修改count变量的值后，由于t1线程不再读取内存，就感知不到count的变化，所以t1线程便“不会停止”。（对于Java虚拟机来说，它并不知道什么时候输入，即使我们在第一时间输入修改count变量的值，相对于计算机来说，还是太慢啦~~）

        针对此内存可见性问题，我们可用volatile关键字修饰count变量，这样就保证Java虚拟机即使优化代码后，也会一直从内存中重新将变量读取至寄存器上。

注意：本篇所说的寄存器也指每个线程各自的工作内存

用volatile关键字修饰后，运行结果就在预期之中了，就解决了内存可见性问题。

volatile 和 synchronized 有本质上的区别：synchronized 能够保证原子性和互斥访问；volatile 则可以保证内存可见性。

3、wait( ) 和 notify( )方法

即 等待 / 通知，是协调线程执行逻辑顺序的两个方法 

3.1、wait( )方法

         使当前执行代码的线程进行等待

         释放当前线程的锁

         被唤醒后会继续获取该锁

wait( ) 要搭配锁来使用，并且该锁要与 synchronzied 的锁对象一致（notify( )则没有要求）

wait 和 join 同样是线程等待，join 是等调用线程执行结束后，才开始执行；而 wait 则是等调用线程执行唤醒方法后就可以执行了，不需要等其结束

3.2、notify( ) 方法

唤醒线程的等待

注意：调用 wait 方法和 notify 方法的锁对象要一致，否则不起作用

public class Demo16 {
    public static Object locker=new Object();//定义一个锁对象
    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(()->{
            synchronized (locker){
                try {
                    System.out.println("t1线程开始");
                    locker.wait();
                    System.out.println("t1线程结束");
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }

        });
        Thread t2=new Thread(()->{
            synchronized (locker){
                System.out.println("t2线程开始");
                locker.notify();
                System.out.println("t2线程结束");
            }
        });
        t1.start();
        Thread.sleep(2000);
        t2.start();
    }
}

        注意：当 t2 线程执行到 notify 方法后，它并不会直接释放该锁，而是执行完该代码块后才释放锁；若多个线程等待，这执行唤醒操作后，只会随机唤醒一个 wait 状态的线程

public class Demo16 {
    public static Object locker=new Object();//定义一个锁对象
    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(()->{
            synchronized (locker){
                try {
                    System.out.println("t1线程开始");
                    locker.wait();
                    System.out.println("t1线程结束");
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        Thread t3=new Thread(()->{
            synchronized (locker){
                try {
                    System.out.println("t3线程开始");
                    locker.wait();
                    System.out.println("t3线程结束");
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        Thread t2=new Thread(()->{
            synchronized (locker){
                System.out.println("t2线程开始");
                locker.notify();
                System.out.println("t2线程结束");
            }
        });
        t1.start();
        t3.start();
        Thread.sleep(2000);
        t2.start();
    }
}

运行结果： 

        上述代码t1线程和t3线程同时在等待t2线程的唤醒操作，但notify只能随机唤醒一个wait状态的线程， 所以总有一个线程不会继续执行而保持wait状态等待唤醒，那我们如何同时唤醒上述两个等待的线程呢？

3.3、notifyAll( )方法 

一次性唤醒所有等待的线程

我们将t2线程中的notify方法更改为notifyAll方法后

        Thread t2=new Thread(()->{
            synchronized (locker){
                System.out.println("t2线程开始");
                locker.notifyAll();
                System.out.println("t2线程结束");
            }
        });

运行结果： 

        此时我们可看到t1和t3线程被全唤醒后，两者会继续竞争同一个锁，上述情况是t1先获取到了锁，执行结束操作，t3先进入阻塞状态，t1线程释放锁后，t3才获取到锁，执行结束操作。所以：被一次性唤醒的多个锁，并不是同时执行，而是先先后后的执行

提醒：wait等待状态的线程并非只有notify方法能唤醒，唤醒的方法如下：

 notify或notifyAll方法唤醒

 含参数的wait方法超时自动唤醒

 其他线程调用等待线程的interrupt()方法，会导致等待线程抛出InterruptedException异常

3.4、wait和sleep的区别 

两者最主要的区别在于对锁的操作

相同点：使得线程放弃执行一段时间

不同点：前者用于线程之间的通信和协调；后者用于让当前线程休眠一段时间

（1）wait 必须搭配锁和synchronzied才能使用，并且使用时会释放锁；而sleep则不需要也不会释放锁

（2）wait是Object的方法，sleep是Thread的静态方法