深入理解线程安全


引言:

在多线程编程中,线程安全是一个至关重要的概念。线程安全可能到导致数据不一致,应用程序崩溃和其他不可预测的后果。本文将深入探讨线程安全问题的根本原因,并通过Java代码示例演示如何解决这些问题。


线程安全的根本原因

这里先观察一个线程不安全的例子:

public class Test {
    private static int count;

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                count++;
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                count++;
            }
        });

        t1.start();
        t2.start();

        t1.join();
        t2.join();


        System.out.println(count);

    }
}

这里我们想要得到 count 的值为200,但是运行的结果却不是。

这里的 count++ 实际操作分为3步:

1. load把数据从内存,读到 cpu 寄存器中(可能先t1,也可能先t2)。

2. add 将寄存器中的数据进行 +1。

3. save 把寄存器中的数据,保存到内存中 。

因为线程的调度是随机的,所以在 count++ 时会出现下面等很多不同的结果

深入理解线程安全_第1张图片

针对以上我们可以知道产生线程安全的原因:

1. 操作系统中,线程的调度是随机的

2. 两个线程针对同一个变量进行修改

3. 修改操作,不是原子性的

    此处count++是 非原子 的操作(先读,再修改)

4. 内存可见性问题

解决线程安全

使用synchronized关键字可以将代码块或方法标记为同步的,这样只有一个线程可以访问它。这可以防止多个线程同时访问共享数据。

public class Test {
    private static int count;
    private static Object locker = new Object();

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(() -> {
            synchronized (locker) {
                for (int i = 0; i < 100; i++) {
                    count++;
                }
            }
        });

        Thread t2 = new Thread(() -> {
            synchronized (locker) {
                for (int i = 0; i < 100; i++) {
                    count++;
                }
            }
        });

        t1.start();
        t2.start();

        t1.join();
        t2.join();


        System.out.println(count);

    }
}

这串代码,对其进行 synchroniezd 加锁后,答案就能是200了

synchronized 的特性

1. 互斥性

2.可重入性

互斥性

synchronized 会起到互斥效果, 某个线程执行到某个对象的 synchronized 中时, 其他线程如果也执行到 同一个对象 synchronized 就会阻塞等待。

进入 synchronized 修饰的代码块, 相当于 加锁

退出 synchronized 修饰的代码块, 相当于 解锁

可重入性

在下面的代码中,increase 和 increase2 两个方法都加了 synchronized, 此处的 synchronized 都是针对 this 当前 对象加锁的. 在调用 increase2 的时候, 先加了一次锁, 执行到 increase 的时候, 又加了一次锁. (上个锁还没释 放, 相当于连续加两次锁)

class Counter {
    public int count = 0;
    synchronized void increase() {
        count++;
    }
    synchronized void increase2() {
        increase();
    }
}

死锁

哲学家就餐问题:

假设有几个哲学家,围着一个桌子(上有一盘菜),每两个人之间有1个筷子,哲学家吃饭的的时间是随机的,吃饭的时候会拿起左右两边的筷子(先拿左边的,没拿起右手的不会放下左手的),正常情况下是可以吃的,但是如果同时拿起左边的筷子,就 " 卡 "到这了 。

深入理解线程安全_第2张图片

死锁的原因

1. 互斥使用,当一个线程持有一把锁时,另一个也想要得到锁,就必须阻塞等待(锁的基本特性)

2. 不可抢占,当锁已经被线程1拿到后,线程2只能等待1主动释放(锁的基本特性)

3. 请求保持,一个线程尝试获取多把锁(代码结构:下面例子)

深入理解线程安全_第3张图片

4. 循环等待(代码结构:哲学家就餐问题)

解决死锁

所以解决死锁1,和 2是锁的本质不能改变

我们只能调整:

对于3来说,改变代码结构

对于4来说,约定加锁的顺序

volatile关键字

1. 保存内存可见性

2. 不保证原子性

保存内存可见性

讨论内存可见性的话,就不得不谈论一下下面的知识点:

计算机cpu访问数据(存在内存中)的时候,会先读出来,放到寄存器中,再进行运算。cpu读内存的操作相对于其他操作来说是比较慢的。所以编译器为了提高效率,把本来要读内存的操作,优化成了读寄存器,减少了读内存的操作。eg:

public class Demo17 {
    private static volatile int isQuit = 0;

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            while (isQuit == 0) {
                // 循环体里啥都没干.
                // 此时意味着这个循环, 一秒钟就会执行很多很多次.
            }
            System.out.println("t1 退出!");
        });
        t1.start();

        Thread t2 = new Thread(() -> {
            System.out.println("请输入 isQuit: ");
            Scanner scanner = new Scanner(System.in);
            // 一旦用户输入的值, 不为 0, 此时就会使 t1 线程执行结束.
            isQuit = scanner.nextInt();
        });
        t2.start();
    }
}

这里即使你输入的不是0,也会一直循环!!!

因此为解决这个问题,就可以在变量的前面加上volatile!!!

你可能感兴趣的:(javaEE,java,开发语言)