总结线程安全问题的原因和解决方案

龙洋静

已于 2024-04-08 09:31:55 修改

阅读量944

点赞数 2

分类专栏： Java 多线程文章标签： java jvm 开发语言

于 2022-09-07 23:07:33 首次发布

本文链接：https://blog.csdn.net/LYJbao/article/details/126751783

版权

Java 同时被 2 个专栏收录

36 篇文章 3 订阅

订阅专栏

多线程

6 篇文章 0 订阅

订阅专栏

五、面试提问：为什么会有线程不安全的问题出现？

一、什么是线程安全？

在操作系统中,因为线程的调度是随机的(抢占式执行),正是因为这中随机性,才会让代码中产生很多bug 如果认为是因为这样的线程调度才导致代码产生了bug,则认为线程是不安全的, 如果这样的调度,并没有让代码产生bug,我们则认为线程是安全的

二、线程不安全带来的问题举例：

售票问题：

public class Test {
    private static int ticketCount=1;
    public static void main(String[] args) {
        //t1模拟售票窗口一
        Thread t1= new Thread(()-> {
            while(ticketCount<100) {
                System.out.println((Thread.currentThread().getName()+"正在卖第："+ticketCount++ +"张票"));
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        //t2模拟售票窗口二
        Thread t2 = new Thread(()-> {
            while(ticketCount<100) {
                System.out.println((Thread.currentThread().getName()+"正在卖第："+ticketCount++ +"张票"));
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        t1.setName("窗口1");
        t2.setName("窗口2");

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

来看输出结果所出现的问题：

看标红的地方，出现了两个窗口售卖同一张票的情况，这就是多线程所导致的线程安全问题

三、线程不安全的原因总结：

1、抢占式执行

————多个线程的调度执行过程，可以视为是“全随机”的

2、多个线程修改同一个变量

3、修改操作不是原子的

原子性：

定义：即一个操作或者多个操作要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。

原子性是拒绝多线程操作的，不论是多核还是单核，具有原子性的量，同一时刻只能有一个线程来对它进行操作。简而言之，在整个操作过程中不会被线程调度器中断的操作，都可认为是原子性。例如 a=1是原子性操作，但是a++和a +=1就不是原子性操作。Java中的原子性操作包括：

（1）基本类型的读取和赋值操作，且赋值必须是值赋给变量，变量之间的相互赋值不是原子性操作。

（2）所有引用reference的赋值操作

（3）java.concurrent.Atomic.* 包中所有类的一切操作

4、内存可见性问题

可见性：

定义：指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。

在多线程环境下，一个线程对共享变量的操作对其他线程是不可见的。Java提供了volatile来保证可见性，当一个变量被volatile修饰后，表示着线程本地内存无效，当一个线程修改共享变量后他会立即被更新到主内存中，其他线程读取共享变量时，会直接从主内存中读取。

5、指令重排序

有序性：
定义：即程序执行的顺序按照代码的先后顺序执行。

Java内存模型中的有序性可以总结为：如果在本线程内观察，所有操作都是有序的；如果在一个线程中观察另一个线程，所有操作都是无序的。前半句是指“线程内表现为串行语义”，后半句是指“指令重排序”现象和“工作内存主主内存同步延迟”现象。

在Java内存模型中，为了效率是允许编译器和处理器对指令进行重排序，当然重排序不会影响单线程的运行结果，但是对多线程会有影响。Java提供volatile来保证一定的有序性。最著名的例子就是单例模式里面的DCL（双重检查锁）。另外，可以通过synchronized和Lock来保证有序性，synchronized和Lock保证每个时刻是有一个线程执行同步代码，相当于是让线程顺序执行同步代码，自然就保证了有序性。

四、解决方案

        通常我们使用同步（关键字为synchronized）来解决这种由于多线程同时操作共享数据带来的线程安全问题。
        同步可以理解为：我们将多条操作共享数据的语句代码包成一个整体，让某个线程执行时其他线程不能执行。
        同步方案包括三种方式，它们对应的锁对象是不一样的。另外我们可以通过加锁来同步代码块，解决安全问题。
因此常用的解决方案有四种。
注意：
同步可以解决问题的根本原因就在于锁对象上，因此要避免线程安全问题，多个线程必须使用同一个锁对象，否则，不能解决问题。

1、同步代码块

格式：synchronized(对象) {
需要被同步的代码;
}

这里的锁对象可以是任意对象。

利用该方法优化后如下：

public class Test1 {
    private static int ticketCount=1;
    private static Object object= new Object();
    public static void main(String[] args) {

        //t1模拟售票窗口一
        Thread t1= new Thread(()-> {
            while(ticketCount<100) {
                synchronized (object) {
                    System.out.println((Thread.currentThread().getName() + "正在卖第：" + ticketCount++ + "张票"));
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        });
         //t2模拟售票窗口二
        Thread t2 = new Thread(()-> {
            while(ticketCount<100) {
                synchronized (object) {
                    System.out.println((Thread.currentThread().getName() + "正在卖第：" + ticketCount++ + "张票"));
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        });
        t1.setName("窗口1");
        t2.setName("窗口2");

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

2、同步方法

格式：把同步（synchronized）加在方法上。

这时的锁对象是this

利用该方法优化后如下：

public class Test2 {
    private static int ticketCount=1;
    public static void main(String[] args) {
        //t1模拟售票窗口一
        Thread t1= new Thread(()-> {
            while(ticketCount<100) {
                sellTicket();
            }
        });
        //t2模拟售票窗口二
        Thread t2 = new Thread(()-> {
            while(ticketCount<100) {
                sellTicket();
            }
        });
        t1.setName("窗口1");
        t2.setName("窗口2");

        t1.start();
        t2.start();
    }
    public static synchronized void sellTicket() {
        System.out.println((Thread.currentThread().getName()+"正在卖第："+ticketCount++ +"张票"));
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

3、静态同步方法

格式：将同步加在静态方法上

此时的锁对象为当前类的字节码文件对象

public class Test3 {
    private static int ticketCount=1;
    public static void main(String[] args) {
        //t1模拟售票窗口一
        Thread t1= new Thread(()-> {
            while(ticketCount<100) {
                //同步代码块实现同步.这里设置的锁对象是该类的字节码文件对象
                synchronized (Test3.class) {
                    sellTicket3();
                }
            }

        });
        Thread t2 = new Thread(()-> {
            while(ticketCount<100) {
                synchronized (Test3.class) {
                    sellTicket3();
                }
            }
        });
        t1.setName("窗口1");
        t2.setName("窗口2");

        t1.start();
        t2.start();
    }
    public static synchronized void sellTicket3 () {
        System.out.println((Thread.currentThread().getName() + "正在卖第：" + ticketCount++ + "张票"));
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

4、加锁Lock解决问题

要用lock和unlock包裹起来才能保证线程安全

public class Test4 {
    private static int ticketCount=1;
    private static Lock lock= new ReentrantLock();
    public static void main(String[] args) {
        //t1模拟售票窗口一
        Thread t1= new Thread(()-> {
            while(ticketCount<100) {
                lock.lock();
                System.out.println((Thread.currentThread().getName()+"正在卖第："+ticketCount++ +"张票"));
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                lock.unlock();
            }
        });
        Thread t2 = new Thread(()-> {
            while(ticketCount<100) {
                lock.lock();
                System.out.println((Thread.currentThread().getName()+"正在卖第："+ticketCount++ +"张票"));
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                lock.unlock();
            }
        });
        t1.setName("窗口1");
        t2.setName("窗口2");

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

本期到这了先，下期见！！！（关于Java中线程安全的类，后续补充）

五、面试提问：为什么会有线程不安全的问题出现？

“线程不安全的问题主要出现在多线程环境中，当一个或多个线程在没有适当同步的情况下，同时访问共享资源或数据时，就可能引发线程不安全的问题。这是因为每个线程都有自己的执行路径和速度，它们可能同时读写同一个变量或对象的状态，导致数据的不一致或不可预测的行为。

具体来说，线程不安全的问题可能由以下几个原因引起：【主要原因总结其实就是上面的目录三】

抢占式执行
多个线程修改一个变量（数据竞争）：当两个或更多线程同时访问一个数据项，并且至少有一个线程在写这个数据项时，就可能发生数据竞争。没有正确的同步，线程间的操作顺序是不确定的，这可能导致不可预见的结果。
原子性问题：某些操作，如自增或自减，看似简单，但实际上是由多个步骤组成的。如果没有原子性保证，一个线程可能在执行这些步骤时被另一个线程打断，导致操作不完整或结果不正确。
可见性问题：由于每个线程都有自己的工作内存，如果一个线程修改了一个变量的值，而其他线程没有及时看到这个修改，就会产生可见性问题。这可能导致线程读取到过时或不一致的数据。【用Java的术语来说，应该是：站在JMM的角度看待volatile，正常的程序执行过程中，会把主内存的数据，先加载到工作内存中，再进行计算处理，编译器优化可能会导致不是每次都真的去读取主内存，而直接读取工作内存中的缓存数据（可能导致内存可见性问题），而volatile起到的效果，就是保证每次读取内存都是真的从主存中重新读取】
指令重排序（顺序问题）：即使单个线程中的操作是有序的，但多线程环境中，线程之间的操作顺序可能会变得不确定。这可能导致依赖于特定操作顺序的代码出现错误。

为了避免线程不安全的问题，我们通常需要使用同步机制，如synchronized关键字、Lock接口的实现类、volatile关键字以及并发工具类（如CountDownLatch、CyclicBarrier、Semaphore等）来确保线程安全。此外，还可以使用并发集合类来避免在集合操作上的线程安全问题。

在Java中，我们还可以通过学习Java的内存模型（JMM）和Happens-Before规则来深入理解线程安全问题，并学会如何编写线程安全的代码。