常见的线程安全问题及解决

1. 什么是线程安全

线程安全指的是当多个线程同时访问一个共享的资源时，不会出现不确定的结果。这意味着无论并发线程的调度顺序如何，程序都能够按照设计的预期来运行，而不会产生竞态条件（race condition）或其他并发问题。

请看如下代码：

我们用两个线程分别让count++ 5w次，最后我们打印count，理论得到的结果是10w

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

        System.out.println("count = " + count);
    }
}

 运行代码:

我们发现结果与我们预期的并不相同。 

其实 count++  是由三个cpu指令来完成的

  • load 从内存中读取数据到cpu寄存器
  • add 把寄存器中的值 +1
  • save 把寄存器中的值写回到内存中

 由于线程之间是并发执行的，每个线程执行到任何一条指令后，都可能从cpu上调度走，而且去执行其他线程，于是当 t1 线程和 t2 线程并发执行时，会存在以下情况。

可以看到 这种情况两次  count++ 实际上只让count+1了，并且实际情况中  t1 的load和add之间又能有更多的指令，那样则会导致 多个count++ 只会令count+1 ，所以导致了结果与预期不符合 

这类问题就称为线程不安全问题。

2. 线程安全问题及解决 

从上面的示例我们可以发现，导致线程不安全的原因是，count++ 这三个指令不是整体执行的，于是我们要解决这个问题就可以想办法使这三个指令为一个整体

2.1 锁 

在Java中我们可以通过加锁的方式来保证线程安全，锁具有 “互斥” “排他” 的特性

在Java中，加锁的方式有很多种，最主要的方式，是通过 synchronized 关键字

语法：

synchronized(锁对象) {
    //要加锁的代码
}

加锁的时候，需要“锁对象”，如果一个线程用一个锁对象加上锁以后，其他线程也尝试用这个锁对象来加锁，就会产生阻塞（BLOCKED），直到前一个对象释放锁

锁对象是一个Object对象

我们给上述ThreadDemo13中 t1, t2 中的count++加上锁：

public class ThreadDemo13 {
    public static int count = 0;

    public static void main(String[] args) throws InterruptedException {
        //随便创建一个对象，作为锁对象,因为所有类默认继承于Object类
        //所以任意一个类的对象都可以作为锁对象
        Object locker = new Object();
        Thread t1 = new Thread(() -> {
            for(int i = 0; i < 50000; i++) {
                synchronized (locker) {
                    count++;
                }
            }
        });

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

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

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

        System.out.println("count = " + count);
    }
}

此时我们再次运行代码：

发现结果正确， 这是因为我们给  t1， t2 中的count都加上了同一个锁，运行代码时， t1 中的count++ 没有执行完时，t2中的 count++ 拿不到锁，就不会执行，同理，t2 中的count++ 没有执行完时，t1中的 count++ 也拿不到锁，也就不会执行。所以就保证了线程安全。

这里我们可以这样理解加锁操作：给代码加锁，就是规定这段代码必须拿到对应的锁才能执行，如果另一个线程中也有代码加了这把锁（即相同的锁对象），同样这段代码也必须拿到这个锁才能执行，但是这个锁只有一个，所以同一时间只能执行一段代码，另一段代码只能等上一段代码执行完，把锁释放了，才能拿到锁进而执行

注意：

  • 加了锁的代码，任然可能中途被调度出cpu，只不过调度出cpu后，任然是加锁状态
  • 只有以同一个锁对象加锁的线程间会产生锁竞争 

 synchronized 还有几种写法

1. 下面这个代码是否是线程安全的？

class Test {
    public static int count = 0;
    public void add() {
        synchronized (this) {
            count++;
        }
    }
}
public class ThreadDemo14 {
    public static void main(String[] args) throws InterruptedException {
        Test t = new Test();
        
        Thread t1 = new Thread(() -> {
            for(int i = 0; i < 50000; i++) {
                t.add();
            }
        });

        Thread t2 = new Thread(() -> {
            for(int i = 0; i < 50000; i++) {
                t.add();
            }
        });

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

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

        System.out.println("count = " + t.count);
    }
}

注意this指的是当前对象，我们发现 调用add的都是t，所以， t1, t2 中 都是通过 t 来加锁，所以存在锁竞争，这段代码是线程安全的：

2.  锁可以加在方法上面

class Test1 {
    public static int count = 0;
    synchronized public void add() {
            count++;
    }
}
public class ThreadDemo15 {
    public static void main(String[] args) throws InterruptedException {
        Test1 t = new Test1();

        Thread t1 = new Thread(() -> {
            for(int i = 0; i < 50000; i++) {
                t.add();
            }
        });

        Thread t2 = new Thread(() -> {
            for(int i = 0; i < 50000; i++) {
                t.add();
            }
        });

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

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

        System.out.println("count = " + t.count);
    }
}

这种写法与上面效果相同，都是通过当前对象加锁

2.2  synchronized 特性

下列代码能否正常打印Ting？

public class ThreadDemo16 {
    public static void main(String[] args) {
        Object locker = new Object();
        Thread t = new Thread(() -> {
            synchronized (locker) { //1
                synchronized (locker) {  //2
                    System.out.println("Ting");
                }// 3
            }// 4
        });
        t.start();
    }
}

答案是可以的：

 解释：在1位置，第一次使用locker加锁，很明显这里是可以加上的，在2位置，这里也在尝试使用locker进行加锁，按照我们上面的理解，这里的锁是加不上的，但是最后却输出了Ting，这里是因为这两次加锁是同一个线程在进行，这种操作是允许的，这个特性称为可重入，这是Java开发者为了防止出现死锁而设计的，

注意：这种写法在1位置才会加锁，在2 位置时，不会真的加锁，在3位置也不会释放锁，在4位置才会释放锁 ，对于可重入锁，内部会有一个加锁次数的计数器，当加锁时计数器为0 才会加锁，每“加一次锁”计数器+1，而每出一个“}”计数器-1，为0时才释放锁

2.3 死锁的三种典型场景 

1. 一个线程，一把锁

如同上面所讲的，如果锁是不可重入锁，并且一个线程，用这把锁加锁两次就会出现死锁

2. 两个线程 两把锁

线程 1 获取到锁 A
线程 2 获取到锁 B
在这种情况下 ，1尝试获取 B, 2尝试获取 A

示例代码 ：
 

public class ThreadDemo17 {
    public static void main(String[] args) {
        Object A = new Object();
        Object B = new Object();
        
        Thread t1 = new Thread(() -> {
            synchronized (A) {
                try {
                    //等 t2 拿到B
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (B) {
                    System.out.println("t1拿到了两把锁");
                }
            }
        });

        Thread t2 = new Thread(() -> {
            synchronized (B) {
                try {
                    //等 t1 拿到A
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (A) {
                    System.out.println("t2拿到了两把锁");
                }
            }
        });
        t1.start();
        t2.start();
    }
}

3. N个线程M把锁

类似于上面的两个线程两把锁的问题，

下面简单画个图演示这种情况：

这种情况下，每个线程都在等待左边的锁被释放，形成一个死锁 

解决：对每把锁都进行编号，规定每个线程都必须先获取编号小的锁，再获取编号大的锁，于是，线程1在获取到锁A前是不会获取锁F的，所以就避免了上述情况。

2.4 内存可见性引起的线程安全问题 

在Java中，多线程共享内存可能会导致内存可见性问题，从而引起线程安全问题。简单来说，内存可见性是指：当一个线程修改了共享变量的值时，这个新值可能不会立即被其他线程所看到

示例代码：

public class ThreadDemo18 {
    public static int flag = 0;
    public static void main(String[] args) {

        int a = 0;
        Thread t1 = new Thread(() -> {
            while(flag == 0) {

            }
            System.out.println("t1线程结束");
        });

        Thread t2 = new Thread(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("把flag置为1");
            flag = 1;
        });

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

当我们运行代码发现：

flag被置为1后 t1线程并没有结束 

 这里我们主要查看这段代码：

这段代码的核心指令只有两条
1. 读取内存中flag的值到cpu寄存器里
2. 拿寄存器里的值和 0 比较

在上述循环中的循环速度是非常快的， 一秒钟可能就运行了几亿次，在这个执行过程中，1操作每次读取的结果都是一样的，并且我们知道，内存的读写速度，相对于2操作的比较速度，是慢得多的，在这个循环中，九成九的时间都在执行1操作，并且运行了很多次(几亿甚至上百亿），读取的值都没有变化，此时JVM 就可能做出优化：不再执行 1 操作，直接用之前寄存器中的值和0做比较。当后面 flag的值变为1后，t1 线程中寄存器中存的值还是0，所以循环不会结束。

我们可以在while中加一个sleep，让循环变慢：

public class ThreadDemo18 {
    public static int flag = 0;
    public static void main(String[] args) {

        int a = 0;
        Thread t1 = new Thread(() -> {
            while(flag == 0) {
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            System.out.println("t1线程结束");
        });

        Thread t2 = new Thread(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("把flag置为1");
            flag = 1;
        });

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

运行代码：

我们发现循环可以正常结束。 

这是因为不加sleep时，一秒钟循环几亿次，操作 1 的整体开销占比是非常大的，优化的迫切程度就更高；加了sleep后一秒循环1000次，操作 1 的整体开销占比就小很多了，优化的迫切程度也就每那么高。

Java中提供了 volatile 关键字，可以使上述优化被关闭 

public class ThreadDemo18 {
    volatile public static int flag = 0;
    public static void main(String[] args) {

        int a = 0;
        Thread t1 = new Thread(() -> {
            while(flag == 0) {
                
            }
            System.out.println("t1线程结束");
        });

        Thread t2 = new Thread(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("把flag置为1");
            flag = 1;
        });

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

运行结果：

volatile 有两个功能 

1. 保证内存可见性
2. 防止指令重排序

2.5 线程饿死 

 Java中的线程饥饿（Thread Starvation），是指某个或某些线程无法获取到所需的CPU时间或其它系统资源，从而陷入长时间的等待状态，无法继续正常执行。这种情况可能会导致程序性能下降、响应时间延长，甚至出现死锁等严重问题。

线程饥饿通常是由于以下几个原因引起的：

  1. CPU资源被占用：当有一个或多个线程占用了大量的CPU资源时，其他线程可能无法获得足够的CPU时间，从而无法正常执行。

  2. 长时间等待资源：当某个线程需要等待某个资源（如锁、I/O操作等）时，如果该资源一直被其他线程占用，那么该线程可能会长时间等待，从而导致线程饥饿。
    示例代码：

    public class ThreadDemo19 {
    public static void main(String[] args) throws InterruptedException {
        Object locker = new Object();

        Thread t1 = new Thread(() -> {
            synchronized (locker) {
                while(true) {
                    //模拟长时间占用锁
                }
            }
        });

        Thread t2 = new Thread(() -> {
            synchronized (locker) {
                System.out.println("执行了t2");
            }
        });

        t1.start();
        //确保t1先拿到locker
        Thread.sleep(100);
        t2.start();
    }
}

  3. 线程优先级不足：当有多个线程同时竞争某个资源时，如果优先级较低的线程一直无法获得该资源，那么它们可能会陷入长时间的等待状态。
    例如：现有 1，2，3 三个线程，线程1 的优先级更高，现在线程1 拿到了锁，但是现在某个条件不满足，线程1无法执行，所以线程1 由把锁释放了，但是线程 1 释放锁之后 任然会参与到锁竞争中，又由于 线程1的优先级高于线程2和线程3，所以任然是线程1拿到锁，于是导致了死锁。这种情况下我们可以使用 wait/notify 解决 让线程1 在条件满足时 再尝试获取锁

2.6 wait / notify 

  1. wait()方法：

    • wait()方法是Object类中定义的方法，可以在任何对象上被调用。它使当前线程释放对象的锁，并让线程进入等待状态，直到其他线程调用相同对象上的notify()或notifyAll()方法将其唤醒。
    • 调用wait()方法会导致当前线程进入等待队列，并释放对象的监视器锁（即释放synchronized块或方法中的锁），允许其他线程获得该锁并执行相应操作。
    • wait()方法可以指定等待的超时时间，如果在指定的时间内没有被唤醒，则线程会自动苏醒。

  2. notify()方法：

    • notify()方法也是Object类中定义的方法，用于唤醒等待在相同对象上的某个线程。它会选择性地通知等待队列中的一个线程，表示该线程可以尝试重新获得对象的锁。
    • 如果有多个线程在等待相同对象上的锁，那么只有其中一个线程会被唤醒，具体唤醒哪个线程是不确定的。
    • notifyAll()方法则会唤醒等待队列中的所有线程。

 示例：

public class ThreadDemo20 {
    public static void main(String[] args) throws InterruptedException {
        Object locker = new Object();
        Thread t1 = new Thread(() -> {
            synchronized (locker) {
                try {
                    System.out.println("wait之前");
                    //wait必须在synchronized内部，因为要释放锁的前提是得加上锁
                    locker.wait();
                    System.out.println("wait之后");
                } catch (InterruptedException e) {
                    //wait 和 sleep join都是一类的可能会被提前唤醒，需要捕获异常
                    e.printStackTrace();
                }
            }
        });
        Thread t2 = new Thread(() -> {
            synchronized (locker) {
                System.out.println("notify之前");
                //Java特别规定notify也必须在synchronized内部
                locker.notify();
                System.out.println("notify之后");
            }
        });
        t1.start();
        Thread.sleep(1000);
        t2.start();
    }
}

 执行过程：

t1 执行后会立刻拿到锁，并且打印 “wait之前” 然后进入wait方法 （释放锁，阻塞等待），然后等待1秒，t2开始执行，拿到锁 打印 “notify”之前 ，然后执行 notify，让 t1 停止阻塞，重新参与锁竞争

注意：wait()可以设置最大等待时间，具体规则和join相同

 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/213480.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

算法设计与实现--贪心篇

算法设计与实现--贪心篇

贪心算法 贪心算法是一种在每一步选择中都采取当前状态下最优决策的算法&#xff0c;以期望能够通过一系列局部最优的选择达到全局最优。贪心算法的关键是定义好局部最优的选择&#xff0c;并且不回退&#xff0c;即一旦做出了选择&#xff0c;就不能撤销。 一般来说&#xf…
阅读更多...
洛谷 P5711 闰年判断 C++代码

洛谷 P5711 闰年判断 C++代码

目录 前言 思路点拨 AC代码 结尾 前言 今天我们来做洛谷上的一道题目。 网址&#xff1a;【深基3.例3】闰年判断 - 洛谷 题目&#xff1a; 思路点拨 首先题目让我们输入一个年份&#xff0c;因此我们需要定义一个变量year&#xff0c;来存储输入的年份&#xff1a; in…
阅读更多...
Bean的加载控制

Bean的加载控制

Bean的加载控制 文章目录 Bean的加载控制编程式注解式ConditionalOn*** 编程式 public class MyImportSelector implements ImportSelector {Overridepublic String[] selectImports(AnnotationMetadata annotationMetadata) {try {Class<?> clazz Class.forName("…
阅读更多...
Nginx 具体应用

Nginx 具体应用

1 Nginx 1.1 介绍 一款轻量级的 Web 服务器/反向代理服务器及电子邮件&#xff08;IMAP/POP3&#xff09;代理服务器。它占有的内存少&#xff0c;并发能力强&#xff0c;中国大陆使用 nginx 的网站有&#xff1a;百度、京东、新浪、网易、腾讯、淘宝等。第一个公开版本发布于…
阅读更多...
Flyway 数据库版本管理 | 专业解决方案

Flyway 数据库版本管理 | 专业解决方案

前言 目前很多公司都是通过人工去维护、同步数据库脚本&#xff0c;但经常会遇到疏忽而遗漏的情况&#xff0c;同时也是非常费力耗时 比如说我们在开发环境对某个表新增了一个字段&#xff0c;而提交测试时却忘了提交该 SQL 脚本&#xff0c;导致出现 bug 而测试中断&#xf…
阅读更多...
vs 安装 qt qt扩展 改迅雷下载qt

vs 安装 qt qt扩展 改迅雷下载qt

Qt5.14.2安装教程和VS2019中的qt环境配置-CSDN博客 1 安装qt 社区版 免费 Download Qt OSS: Get Qt Online Installer 2 vs安装 qt vs tools 3 vs添加 qt添加 bin/cmake.exe 路径 3.1 扩展 -> qt versions 3.2 4 新版要源码安装 需要自己安装 安装独立安装的旧版 官网…
阅读更多...
go自定义端口监听停用-------解决端口被占用的问题

go自定义端口监听停用-------解决端口被占用的问题

代码 package mainimport ("fmt""log""net""os/exec""strconv""strings" )func getSelect(beign int, end int) int {var num intfor {_, err : fmt.Scan(&num)if err ! nil {fmt.Println("输入错误&am…
阅读更多...
【c】角谷猜想

【c】角谷猜想

#include<stdio.h> int coll(int x)//定义函数 {int count0;while(x>1){if(x%20){xx/2;count;}else{x3*x1;count;}}return count; } int main() {int n,num;scanf("%d",&n);int arr[n1];for(int i1;i<n;i)//输入n组数据保存到数组中{scanf("%d&…
阅读更多...
Python图表神器：Matplotlib库绘制图表轻松有趣

Python图表神器：Matplotlib库绘制图表轻松有趣

更多资料获取 &#x1f4da; 个人网站&#xff1a;ipengtao.com Matplotlib是Python中用于绘制图表和数据可视化的重要库。它提供了丰富的功能和灵活性&#xff0c;可用于生成各种类型的图表&#xff0c;从简单的折线图到复杂的三维图表。 1. 基本图表绘制 折线图 Matplotl…
阅读更多...
【【Micro Blaze 的 最后补充 与 回顾 】】

【【Micro Blaze 的 最后补充 与 回顾 】】

Micro Blaze 的 最后补充 与 回顾 Micro Blaze 最小系统 以 MicroBlaze 为核心、LocalMemory&#xff08;片上存储&#xff09;为内存&#xff0c;加上传输信息使用的 UART串口就构成了嵌入式最小系统。当程序比较简单时&#xff0c;Local Memory 可以作为程序的运行空间以及…
阅读更多...
如何调用 API | 学习笔记

如何调用 API | 学习笔记

开发者学堂课程【阿里云 API 网关使用教程:如何调用 API】学习笔记&#xff0c;与课程紧密联系&#xff0c;让用户快速学习知识。 课程地址&#xff1a;阿里云登录 - 欢迎登录阿里云&#xff0c;安全稳定的云计算服务平台 如何调用 API 调用 API 的三要素 要调用 API 需要三…
阅读更多...
9-3用结构体定义学生，用函数输出学生成绩

9-3用结构体定义学生，用函数输出学生成绩

#include<stdio.h>struct student{char name[10];int num;char score[3]; }stu[5]; //结构体输入信息int main(){void print(struct student str[5]);int i,j;for(i0;i<5;i){printf("第%d个学生信息如下&#xff1a;\n",i1);printf("name:");scan…
阅读更多...
synchronized的实现原理

synchronized的实现原理

程序员的公众号&#xff1a;源1024&#xff0c;获取更多资料&#xff0c;无加密无套路&#xff01; 最近整理了一波电子书籍资料&#xff0c;包含《Effective Java中文版 第2版》《深入JAVA虚拟机》&#xff0c;《重构改善既有代码设计》&#xff0c;《MySQL高性能-第3版》&…
阅读更多...
Redis--14--BigKey 和 热点Key

Redis--14--BigKey 和 热点Key

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 BigKey1.什么是bigkey2.bigkey的危害3.发现bigkeyscan 4.解决bigkey 什么是热点Key&#xff1f;该如何解决1. 产生原因和危害原因危害 2.发现热点key预估发现客户端…
阅读更多...
基于深度学习的肺炎CT图像检测诊断系统

基于深度学习的肺炎CT图像检测诊断系统

欢迎大家点赞、收藏、关注、评论啦 &#xff0c;由于篇幅有限&#xff0c;只展示了部分核心代码。 文章目录 一项目简介 二、功能三、系统四. 总结 一项目简介 深度学习在肺炎CT图像检测诊断方面具有广泛的应用前景。以下是关于肺炎CT图像检测诊断系统的介绍&#xff1a; 任务…
阅读更多...
【STM32】STM32学习笔记-软件安装(03)

【STM32】STM32学习笔记-软件安装(03)

00. 目录 文章目录 00. 目录01. MDK安装02. Keil5注册03. 支持包安装04. ST-LINK驱动安装05. USB转串口驱动06. 附录 01. MDK安装 MDK 源自德国的 KEIL 公司&#xff0c;是 RealView MDK 的简称。在全球 MDK 被超过 10 万的嵌入式开发工程师使用。目前最新版本为&#xff1a; …
阅读更多...
本地源文件-丰富的图表-

本地源文件-丰富的图表-

D:\FineReport_11.0\webapps\webroot\WEB-INF\reportlets\demo\basic 图表类型:http://localhost:8075/webroot/help/demo.html 可视化图表&#xff0c;丰富的图表:help/demo.html http://localhost:8075/webroot/decision#management/directory 参数查询/条件查询与图…
阅读更多...
HTML块元素和行内元素

HTML块元素和行内元素

HTML块元素和行内元素 1.分类2.块元素3.行内元素 1.分类 在HTML中&#xff0c;根据元素的表现形式&#xff0c;一般可以分为两类&#xff1a; 块元素&#xff08;block&#xff09;行内元素&#xff08;inline&#xff09; 2.块元素 在HTML中&#xff0c;块元素在浏览器显示…
阅读更多...
12.3_黑马MybatisPlus笔记（上）

12.3_黑马MybatisPlus笔记（上）

目录 02 03 04 05 06 07 ​编辑 thinking:system.out::println?​编辑 thinking&#xff1a;list.of? 08 thinking&#xff1a;RequestParam和 ApiParam注解使用&#xff1f; thinking&#xff1a;RequestParam 和PathVariable的区别&#xff1f; ​编辑 ​编…
阅读更多...
栈的链式存储（详解）

栈的链式存储（详解）

栈的链式存储 栈的链式存储是通过链表来实现的&#xff0c;每个节点包含一个元素和一个指向下一个节点的指针。链式存储的栈不需要提前分配内存空间&#xff0c;可以动态地增加或减少元素。 在链式存储中&#xff0c;栈顶元素通常是链表的头节点&#xff0c;栈底元素是链表的…
阅读更多...
最新文章

Copyright @ 2022~2023