当前位置： 首页 > article >正文

【Java多线程】线程安全及解决方案（详解）

article 2024/11/14 2:37:20

目录

线程安全问题引入：

线程安全原因  

如何解决线程安全问题？

（1）synchronized关键字

1)sychronized关键字的特性: 

2)可重⼊

 synchronized使⽤⽰例

（2）volatile关键字

1）内存可见性和指令重排序

2） volatile不保证原⼦性

3）volatile总结：

线程安全问题引入：

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

执行结果：
count=14423

执行结果：
count=10223

执行结果：
count=12123

由此可见，我们正常情况下想得到的结果为20000，而现在的结果却不尽人意 很明显在此情况下代码出现了bug。

 因为多个线程并发执行，引起的bug,这样的bug称为“线程安全问题”或者叫做“线程不安全”

线程安全原因  

问题分析：

（1）线程在操作系统中是随机调度，抢占式执行的【根本原因】

（2）当前代码中多个线程修改一个变量 

多个线程修改同⼀个变量
上⾯的线程不安全的代码中,涉及到多个线程针对 count 变量进⾏修改.
此时这个 count 是⼀个多个线程都能访问到的"共享数据

（3）修改操作，不是“原子”的

不保证原⼦性会给多线程带来什么问题
如果⼀个线程正在对⼀个变量操作，中途其他线程插⼊进来了，如果这个操作被打断了，结果就可能是错误的。

count++操作实际上分成三步：

1）load 从内存中读取数据到cpu的寄存器

2）add 把寄存器中的值+1

3）save 把寄存器的值写回内存中

而由于线程调度是随机调度，抢占式执行的，这就导致了两个线程的count++操作三步骤是会被打乱顺序的。

还有其他原因稍后介绍... 

如何解决线程安全问题？

（1）synchronized关键字

1)sychronized关键字的特性: 

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

• 进⼊synchronized修饰的代码块,相当于加锁
• 退出synchronized修饰的代码块,相当于解锁

public class demo2 {
    public static int count  = 0;
    public static void main(String[] args) throws InterruptedException {
        Object locker = new Object();
        Thread t1 = new Thread(()->{
            synchronized (locker) {
                for (int i = 0; i < 10000; i++) {
                    count++;
                }
            }
        });
        Thread t2 = new Thread(()->{
            synchronized (locker) {
                for (int i = 0; i < 10000; i++) {
                    count++;
                }
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(count);
    }
}

通过对count++的整体加锁，使得每一次的count++都是一个整体，解决了此处的线程安全问题。

加锁的过程： 

可以粗略理解成,每个对象在内存中存储的时候,都存有⼀块内存表⽰当前的"锁定"状态(类似于厕所
的"有⼈/⽆⼈").
如果当前是"⽆⼈"状态,那么就可以使⽤,使⽤时需要设为"有⼈"状态.
如果当前是"有⼈"状态,那么其他⼈⽆法使⽤,只能排队

  • 上⼀个线程解锁之后,下⼀个线程并不是⽴即就能获取到锁.⽽是要靠操作系统来"唤醒".这也就是操作系统线程调度的⼀部分⼯作.
  • 假设有ABC三个线程,线程A先获取到锁,然后B尝试获取锁,然后C再尝试获取锁,此时B和C都在阻塞队列中排队等待.但是当A释放锁之后,虽然B⽐C先来的,但是B不⼀定就能获取到锁,⽽是和C重新竞争,并不遵守先来后到的规则.
2)可重⼊

synchronized同步块对同⼀条线程来说是可重⼊的，不会出现⾃⼰把⾃⼰锁死的问题 

按照之前对于锁的设定,第⼆次加锁的时候,就会阻塞等待.直到第⼀次的锁被释放,才能获取到第⼆个锁.但是释放第⼀个锁也是由该线程来完成,结果这个线程已经躺平了,啥都不想⼲了,也就⽆法进⾏解锁操作.这时候就会死锁 

for (int i = 0; i < 50000; i++) {
synchronized (locker) {
synchronized (locker) {
        count++;
        }
    }
}
public class demo2 {
    public static int count  = 0;
    public static void main(String[] args) throws InterruptedException {
        Object locker = new Object();
        Thread t1 = new Thread(()->{
            synchronized (locker) {
                synchronized (locker) {
                    for (int i = 0; i < 10000; i++) {
                        count++;
                    }
                }
            }
        });
        Thread t2 = new Thread(()->{
            synchronized (locker) {
                synchronized (locker) {
                    for (int i = 0; i < 10000; i++) {
                        count++;
                    }
                }
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("count="+count);
    }
}

count=20000

 synchronized使⽤⽰例

1)修饰代码块:明确指定锁哪个对象.

锁任意对象


public class SynchronizedDemo {
    private Object locker = new Object();
    public void method() {
        synchronized (locker) {
        }
    }
}

 锁当前对象 

public class SynchronizedDemo {
    public void method() {
        synchronized (this) {
            
        }
    }
}

2)直接修饰普通⽅法:锁的SynchronizedDemo对象 

public class SynchronizedDemo {
    public synchronized void methond() {
    }
}

3)修饰静态⽅法:锁的SynchronizedDemo类的对象 

public class SynchronizedDemo {
    public synchronized static void method() {
    }
}

 我们重点要理解，synchronized锁的是什么.两个线程竞争同⼀把锁,才会产⽣阻塞等待.

 两个线程分别尝试获取两把不同的锁,不会产⽣竞争.

（2）volatile关键字

1）内存可见性和指令重排序

 还有一直情况就是“内存可见性”和“指令重排序”引发的线程安全

下列代码原本用意是：当用户输入非0数字时，结束线程t1。 

import java.util.Scanner;
public class demo3 {
    private static  int flag = 0;
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            while (flag == 0) {
                // 循环体里, 啥都不写会触发内存可见性问题
            }
            System.out.println("t1 线程结束!");
        });
        Thread t2 = new Thread(() -> {
            System.out.println("请输入 flag 的值: ");
            Scanner scanner = new Scanner(System.in);
            flag = scanner.nextInt();
        });
        t1.start();
        t2.start();
    }
}

在这个代码中
• 创建两个线程t1和t2
• t1中包含⼀个循环,这个循环以flag==0为循环条件.
• t2中从键盘读⼊⼀个整数,并把这个整数赋值给flag.

可结果是：

t1读的是⾃⼰⼯作内存中的内容.
当t2对flag?变量进⾏修改,此时t1感知不到flag的变化.

//如果给flag加上volatile
private static volatile int flag = 0;
import java.util.Scanner;
public class demo3 {
    private static volatile int flag = 0;
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            while (flag == 0) {
                // 循环体里, 啥都不写会触发内存可见性问题
            }
            System.out.println("t1 线程结束!");
        });
        Thread t2 = new Thread(() -> {
            System.out.println("请输入 flag 的值: ");
            Scanner scanner = new Scanner(System.in);
            flag = scanner.nextInt();
        });
        t1.start();
        t2.start();
    }
}

2）volatile不保证原⼦性
public class demo3 {
   private static volatile 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=68741

此时可以看到,最终count的值仍然⽆法保证是100000.

3）volatile总结：

1. 内存可见性

在多线程环境下，每个线程都有自己的本地内存（例如 CPU 的寄存器和缓存），当线程修改一个变量时，修改的内容可能只会被保存在线程的本地内存中，而不是立即刷新到主内存中。这可能导致其他线程读取该变量时，看到的是过时的数据。

volatile 关键字确保了：

  • 当一个线程修改 volatile 变量时，修改后的值会立即刷新到主内存。

  • 其他线程读取这个 volatile 变量时，会直接从主内存中读取最新的值，而不是从自己的本地缓存中读取。

2. 禁止指令重排

volatile 变量还具有防止指令重排的效果。指令重排是现代处理器为了提高性能，在程序执行时调整指令执行顺序的行为。它可能导致程序出现一些非预期的结果，特别是在多线程编程中。

volatile 关键字保证了变量的读写顺序不会被重排，因此它能确保代码在多个线程中的执行顺序符合预期。

3. 不具备原子性

volatile 关键字虽然可以确保内存可见性和禁止指令重排，但并不具备原子性。也就是说，如果对一个 volatile 变量进行复合操作（例如：i++），它并不能保证操作的原子性。因为复合操作通常涉及多个步骤，如读取值、修改值、写回主内存，这些步骤不能保证在多线程环境下不会被打断。因此，volatile 只能用于简单的赋值操作。

 synchronized关键字vs volatile关键字

特性synchronizedvolatile
作用提供互斥性和可见性，确保一个线程执行某个方法时，其他线程不能访问被保护的代码块。仅保证变量的可见性，确保一个线程对该变量的修改能够立刻反映到其他线程。
性能开销存在较高的性能开销，因为它涉及到线程的加锁和解锁操作。相对较低的性能开销，只在访问volatile变量时有较小的性能影响。
原子性提供原子性，确保多线程在同一时刻只会有一个线程访问同步方法或同步代码块。不保证原子性，仅仅保证可见性。例如 volatile 不能保证 ++ 操作的原子性。
使用场景适用于需要保证原子性和互斥访问的场景，如多个线程同时修改共享变量。适用于多线程间共享变量的简单读写场景，特别是标志位和开关。

总结

  • synchronized：适用于需要保证线程安全和原子性操作的场景，通过加锁来保证一个线程在执行某个代码块时，其他线程无法同时访问这些代码，从而避免并发问题。
  • volatile：适用于保证多线程之间共享变量的可见性，尤其是用于标志位等简单的读写操作，但它不保证操作的原子性，因此不适用于需要进行复合操作的情况。

在实际应用中，如果一个变量的读写操作不涉及复杂的计算和操作，且只需要保证它的可见性，可以考虑使用 volatile。如果需要对共享资源进行复杂操作（如累加、修改多个共享变量等），则需要使用 synchronized 来保证互斥性和原子性。

 

 结语： 写博客不仅仅是为了分享学习经历，同时这也有利于我巩固知识点，总结该知识点，由于作者水平有限，对文章有任何问题的还请指出，接受大家的批评，让我改进。同时也希望读者们不吝啬你们的点赞+收藏+关注，你们的鼓励是我创作的最大动力！ 


http://www.kler.cn/a/389677.html

相关文章：

  • 【金融风控】特征评估与筛选详解
  • Unity3D学习FPS游戏（11）敌人AI巡逻（NavMesh）
  • WordPress 2024主题实例镜像
  • 7天用Go从零实现分布式缓存GeeCache（学习）（3）
  • Spring框架之适配器模式 (Adapter Pattern)
  • linux安装netstat命令
  • monkey-安卓稳定性测试
  • Web3 游戏周报（11.03 - 11.09）
  • springboot苍穹外卖实战：十一：复盘总结
  • 除草机器人算法以及技术详解！
  • Debezium日常分享系列之：异步 Debezium 嵌入式引擎
  • 【计算机图形学】3DIT的训练数据总结
  • 问：说说Spring中构造函数注入和Setter注入的区别？
  • Maven 中央仓库地址 mvnrepository.com
  • Maven从浅入深（理解篇）
  • K8S之Prometheus 部署（二十）
  • 《实时流计算系统设计与实现》-Part 1-笔记
  • 算法每日双题精讲——滑动窗口（长度最小的子数组，无重复字符的最长子串）
  • FreeRTOS学习11——时间片任务调度
  • 基于多设计模式下的同步异步日志系统
  • C0028.在Clion中快速生成头文件中声明的函数的方法
  • 「Mac畅玩鸿蒙与硬件29」UI互动应用篇6 - 多选问卷小应用
  • Qt QCustomplot 在采集信号领域的应用
  • 5G NR协议栈分层
  • 2024年【R2移动式压力容器充装】考试试题及R2移动式压力容器充装操作证考试
  • AscendC从入门到精通系列（三）基于自定义算子工程开发AscendC算子