（多线程）synchronized---volatile

目录

🍡🍷线程安全问题🍡

🍡synchronized🍡

🍷 原因🍷

🍷解决方法🍷

🍷注意🍷

🍡volatile🍡

🍷原因🍷

🍷解决方法🍷

🍡总结（重点）🍡

---

线程安全问题

        在之前的单线程环境下并不涉及线程安全问题，但是多线程环境下，我们前面讲过，多线程在cpu上的调度执行是随机的，无序的，就需要注意线程安全问题，如果没有处理好，就会导致程序运行结果与预期结果不符。

        一般来讲，我们针对线程安全问题的处理方式为，给有线程安全问题的代码部分加锁或者使用volatile。但是不能盲目的加，我们一方面要考虑线程安全问题，一方面也要考虑程序执行的效率问题，所里下面来了解一下什么情况下会出现线程安全问题。

synchronized

class Counter{
    private int count;
    public void add(){
        count++;
    }
    public int get(){
        return count;
    }
}
public class ThreadSafe1 {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                counter.add();
            }
        });
        Thread t2 = new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                counter.add();
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(counter.get());
    }
}

我们看这段代码，功能就是从1加到10000，我们预期输出结果是10000，但是实际运行结果为：

 

我们看到结果并不是10000，并且每次运行的结果都是不定的。

 原因

       代码的t1和t2线程中，我们是通过“count++”来计算的，我们代码上“count++”只是一行代码，看起来就是一步操作。但是，实际上在执行“++”操作时，是执行了三步：

而线程的执行是随机的，无序的，所以这三步操作可能不是在一次都执行到。

 

       我们一次++为例，当t1线程++操作执行到load的时候（此时寄存器的值被load为0），由于线程的无序随机调度，线程t1从cpu上调走，t2线程来执行 再次执行到++操作，这次t2线程也要执行load，add，save（寄存器load为0，add为1，save为1）。然后t2线程调走，t1线程回来，根据上下文属性，接着上次t1执行的接着往下执行，就是add和save（上次load为0，所以add为1，save为1）。我们就发现了问题，经过两次++操作，我们预期结果为2，但是实际count  =  1。load，add，save三条指令的排序有很多种，在后面的循环中就会有很多不可预期的结果。所以导致我们执行的结果是错误的并且是随机的。

解决方法

synchronized给需要枷锁的代码加锁。

       经过上面错误原因的分析，我们知道出错的原因是count++操作不是原子操作，可能发生指令重排序，所以我们就给这段代码加锁，保证线程执行到count++操作时会把三步都执行完再去无序调度。这样就可以保证结果的正确。

class Counter{
    private int count;
    public void add(){
        count++;
    }
    public int get(){
        return count;
    }
}
public class ThreadSafe1 {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        //创建一个锁对象
        Object block = new Object();
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                synchronized (block) {
                    counter.add();
                }
            }
        });
        Thread t2 = new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                synchronized (block) {
                    counter.add();
                }
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(counter.get());
    }
}

注意

       使用synchronized时要指定一个锁对象，例如上面问题，错误原因是：多线程针对++操作的指令从排序。我们的解决方法是：给++操作加锁，保证一个线程在执行这步操作时，是会执行完才会有可能被调走。所以这些线程都要对这个操作进行锁竞争，拿到锁的可以执行锁内部的++操作，++操作执行结束才会释放锁，然后再次多个线程竞争锁。所以这个锁对象必须一致，表示多个线程针对同一个把锁竞争。

volatile

public class ThreadSafe2 {
     static int flg ;
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Thread t = new Thread(()->{
           while (flg == 0){
             //让线程空转着
           }
            System.out.println("运行结束");
        });
        t.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("请输入一个整数：");
        flg = scanner.nextInt();
    }
}

        这段代码的目的就是让t线程一直空转，当我们在控制台输入非0的数时就会打印 运行结束。这也是我们的预期结果。

可以看出并没有按照我们的预期结果执行，当我们输入一个非0的数时程序并不会停止。

原因

有内存可见性问题引起的

        在上述代码中，t线程在一直空转，这个过程中也是分为两步，1. load将内存的数据读到寄存器中  2. 比较寄存器的值和0.。由与计算机执行速度是飞快的，当我们输入数字的时候，这个空转已经执行力很多次了，编译器在每次load数据时发现结果都一样，而且load操作开销也很大，编译器就会自动进行优化，不在load操作。这也导致后面我们输入一个非0数时，并没有按照我们的预期执行。 

解决方法

我们使用volatile关键词保证内存可见性，保证程序每次都会去内存load。

public class ThreadSafe2 {
    volatile static int flg ;
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Thread t = new Thread(()->{
           while (flg == 0){
             //让线程空转着
           }
            System.out.println("运行结束");
        });
        t.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("请输入一个整数：");
        flg = scanner.nextInt();
    }
}

可以看到当我们输入非0数时，打印了运行结束。符合我们的预期。

总结（重点）

出现线程安全问题的原因总结（一般情况）