线程安全的原因及解决方法

什么是线程安全问题

线程安全问题指的是在多线程编程环境中,由于多个线程共享数据或资源,并且这些线程对共享数据或资源的访问和操作没有正确地同步,导致数据的不一致、脏读、不可重复读、幻读等问题。线程安全问题的出现,通常是因为线程之间的并发执行导致了数据竞争(Race Condition)或者时序问题(Timing Issues)。以上是网上找到的回答,我认为只要是在多线程代码实现产生bug都可以称为线程安全问题.

线程安全问题举例


public class ThreadDemo {
    public static int count;
    public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                    count++;
                }

        });
        Thread t1=new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                    count++;
            }
        });
        t.start();
        t1.start();
        t.join();
        t1.join();
        System.out.println(count);
    }
}

这串代码预期结果是10000,但是无论执行多少次都达不到预期的效果

 这里主要原因涉及到指令的执行顺序

因为很多操作在cpu上都会又细分为多个操作,例如count++分为 load,add,save,多线程不能穿插执行,必须要等第一个线程操作完数据保存到内存后,第二个再执行,不正常的执行顺序,可能会将其中一个线程操作的数据覆盖等影响,大概率结果会有错误

线程安全的五大原因

1.系统调度是随机的:

线程在系统中随机调度,是抢占式执行的,这种情况我无法修改和干预,当多个线程访问并修改同一内存位置的数据时,由于线程的随机调度,可能导致数据的不一致性

2.原子性问题:

某些操作(如自增、自减等)在单线程环境下是原子的,但在多线程环境下可能不是原子的。这些操作可能被拆分成多个步骤,(希望的是每个cpu指令都是原子的,要么不执行,执行就执行完为止)从而导致数据的不一致性,上面的代码线程不安全主要是原子性问题

3.内存可见性问题:

由于Java内存模型的原因,一个线程对共享变量的修改可能无法立即被其他线程看到。这可能导致线程读取到旧的数据值,从而引发问题

4指令重排序:编译器和处理器为了提高性能,可能会对指令进行重排序。但在多线程环境下,这种重排序可能会破坏代码的语义,导致线程安全问题。

线程安全问题的解决方法

加锁synchronized

public class ThreadDemo1 {
    public static int count;
    public static void main(String[] args) throws InterruptedException {
        String s="锁无所谓是什么变量";
        Thread t=new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                synchronized (s){
                    count++;
                }
            }
        });
        Thread t1=new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                synchronized (s){
                    count++;
                }
            }
        });
        t.start();
        t1.start();
        t.join();
        t1.join();
        System.out.println(count);
    }
}

这样锁就把count打包成一个操作了,是原子性,当执行count的时候就不会出现执行一半的情况

加锁后需要注意几点

1.此时count++操作是串行执行,其余操作例如for循环都是并行执行

2.如果两个线程同时尝试加锁,此时只有一个线程可以获取锁成功,而另一个线程就会阻塞      等待。阻塞到另一个线程释放锁之后,当前线程才能获取锁成功。

3.当t1释放锁之后,t1线程还是会同时争夺这把锁

可重入锁

可重入锁指的是,本身加锁的线程能够加第二次锁,直接通过不会阻塞(写错了也能执行),下面的例子就是给一个程序加了两次锁,依旧可以执行成功

public class ThreadDemo1 {
    public static void main(String[] args) {
        Object locker =new Object();
        Thread t1=new Thread(()->{
            synchronized (locker){
                synchronized (locker){
                    System.out.println("hi");
                }
            }
        });
        t1.start();
    }
}

死锁

死锁(Deadlock)是一个或多个线程因为竞争资源而造成的一种状态,在这种状态下,线程们会无限期地等待一个永远不会发生的条件,从而导致程序无法继续执行。

死锁的经典的三种场景

1.一个线程一把锁,如果是不可重入锁,在加上一把锁,就会出现死锁

2.两个线程,两把锁,第一个线程有A锁,第二个线程有B锁,第一个线程又尝试获取B锁,第二线程尝试获取A锁,就会出现死锁


public class ThreadDemo2 {
    public static void main(String[] args) {
        Object A=new Object();
        Object B=new Object();
        Thread t1=new Thread(()->{
           synchronized(A){
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               synchronized (B){
                   System.out.println("t1两把锁");
               }
           }
        });
        Thread t2=new Thread(()->{
           synchronized (A){
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               synchronized (B){
                   System.out.println("t2两把锁");
               }
           }
        });
        t1.start();
        t2.start();
    }
}

3.哲学家吃面问题/N个线程M把锁

        假设有五位哲学家围坐在一张圆形餐桌旁,每人面前有一碗面,每两个哲学家之间有一只筷子。因为用一只筷子很难吃到面,所以哲学家必须用两只才能吃到面,而他们只能使用自己左右手边的那两只。哲学家们有两种状态:进餐或思考。每当一个哲学家饥饿时,他会试图去拿他左右两边的筷子,但每次只能拿一只。只有当他拿到两只筷子时,才能开始进餐,吃完后需要放下餐叉继续思考。

在这个问题中,筷子是共享资源,而哲学家们对筷子的竞争可能导致死锁的发生。例如,如果每个哲学家都拿起左手边的筷子,等待右手边的餐叉变得可用,而右手边的筷子又被其他哲学家持有,那么就会形成死锁状态,因为每个哲学家都在等待其他哲学家释放资源,而这永远不会发生。

 怎么避免死锁
  1. 设置加锁顺序(最好的方法):线程按照一定的顺序加锁,确保每个线程在请求多个锁时都按照相同的顺序进行。这样可以防止循环等待的情况,从而降低死锁的风险。设置加锁顺序,使得每位哲学家在尝试拿起筷子时都遵循相同的顺序。例如,可以规定所有哲学家都先尝试拿起自己左侧的筷子,然后再拿起右侧的筷子。这样,在任何时候,最多只有一个哲学家能够拿起他左右两侧的筷子,从而避免了死锁的情况
  2. 避免使用多个锁:尽量将代码设计成只使用一个锁的情况,减少因为多个锁之间的依赖关系导致的死锁4。
  3. 设置加锁时限(超时重试):在获取锁的时候尝试加一个获取锁的时限,超过时限则放弃操作并释放之前获取到的锁,然后等待一段时间后进行重试。这种方法允许在没有获取锁的时候继续执行其他任务,减少死锁的可能性。

volatile

当一个程序读,一个程序写的时候,此时就容易出现内存可见性问题,volatile就是解决这个问题的,其中一个核心功能就是保证内存可见性

下面的例子创建了两个线程,一个线程不断判断变量的值死循环,另一个等待输入值,使死循环停止,当我们改变flag之后,t1线程并没有结束,这里解释一下原因是编译器发现每次循环都要读取内存,开销太大,于是就把读取内存操作优化为读取寄存器操作,提高效率,就导致写线程做出的修改,读线程感知不到

import java.util.Scanner;
 
class Counter {
    public int flag;
}
 
public class ThreadDemo {
    public static void main(String[] args) {
 
        Counter counter = new Counter();
        Thread t1 = new Thread(()->{
           while(counter.flag==0){
               //此处为了代码简洁好演示,什么都不做
           }
        });
 
        Scanner sc = new Scanner(System.in);
        Thread t2 = new Thread(()->{
            counter.flag = sc.nextInt();
        });
 
        t1.start();
        t2.start();
    }
}

当我们在while循环中加上sleep后发现代码可以执行成功了,因为之前一直循环一秒钟可能循环上百亿次,在循环中加上sleep一秒钟也就执行上百次,大大减少开销

这里最主要的解决方法是加上volatile,告诉编译器这里不需要优化

public volatile int flag=0;//保证内存可见性,禁止指令重排序

 

相关推荐

  1. 线安全问题原因解决方案

    2024-07-09 17:14:02       31 阅读
  2. 面试题:Go协泄漏原因解决方法

    2024-07-09 17:14:02       18 阅读

最近更新

  1. js弹出对话框

    2024-07-09 17:14:02       0 阅读
  2. 优先级策略:在Eureka中配置服务实例优先级

    2024-07-09 17:14:02       0 阅读
  3. L298N的输出电流与电压

    2024-07-09 17:14:02       0 阅读
  4. 基于vite + pnpm monorepo 实现一个UI组件库

    2024-07-09 17:14:02       0 阅读
  5. sqlserver15(2019)修改参数READ_COMMITTED_SNAPSHOT

    2024-07-09 17:14:02       0 阅读
  6. 黑龙江网络安全等级保护测评策略概述

    2024-07-09 17:14:02       0 阅读
  7. Hi3751V351常用命令

    2024-07-09 17:14:02       0 阅读
  8. 鸿蒙笔记--存储

    2024-07-09 17:14:02       0 阅读

热门阅读

  1. 大二暑假 + 大三上

    2024-07-09 17:14:02       9 阅读
  2. Git 常用命令及其作用

    2024-07-09 17:14:02       6 阅读
  3. Docker

    Docker

    2024-07-09 17:14:02      8 阅读
  4. C++多线程学习笔记

    2024-07-09 17:14:02       9 阅读
  5. 实现基于Spring Cloud的事件驱动微服务

    2024-07-09 17:14:02       9 阅读
  6. js使用websocket,vue使用websocket,copy即用

    2024-07-09 17:14:02       7 阅读