JUC并发编程--------线程安全篇

Promise_J_Z2023-09-15 16:52

目录

什么是线程安全性问题？

如何实现线程安全？

1、线程封闭

2、无状态的类

3、让类不可变

4、加锁和CAS

并发环境下的线程安全问题有哪些？

1、死锁

2、活锁

3、线程饥饿

什么是线程安全性问题？

我们可以这么理解，我们所写的代码在并发情况下使用时，总是能表现出正确的行为；反之，未实现线程安全的代码，表现的行为是不可预知的，有可能正确，而绝大多数的情况下是错误的。正如Java语言规范在《Chapter 17. Threads and Locks》所说的：

图中标红文字的意思是：线程的行为（尤其是在未正确同步的情况下）可能会造成混淆并且违反直觉。本章描述了多线程程序的语义。它包括规则，通过读取多个线程更新的共享内存可以看到值。

如果要实现线程安全性，就要保证我们的类是线程安全的的。在《Java并发编程实战》中，定义"类是线程安全的"如下：

当多个线程访问某个类时，不管运行时环境采用何种调度方式或者这些线程将如何交替执行，并且在调用代码中不需要任何额外的同步或者协同，这个类都能表现出正确的行为，那么就称这个类是线程安全的。

如何实现线程安全？

1、线程封闭

把对象封装到一个线程里，只有这一个线程能看到此对象。那么这个对象就算不是线程安全的也不会出现任何安全问题。举个例子

  • 栈封闭

栈封闭是我们编程当中遇到的最多的线程封闭。什么是栈封闭呢？简单的说就是局部变量。多个线程访问一个方法，此方法中的局部变量都会被拷贝一份到线程栈中。所以局部变量是不被多个线程所共享的，也就不会出现并发问题。所以能用局部变量就别用全局的变量，全局变量容易引起并发问题。

  • TheadLocal

ThreadLocal是实现线程封闭的最好方法。ThreadLocal内部维护了一个Map，Map的key是每个线程的名称，而Map的值就是我们要封闭的对象。每个线程中的对象都对应着Map中一个值，也就是ThreadLocal利用Map实现了对象的线程封闭。

2、无状态的类

没有任何成员变量的类，就叫无状态的类，这种类一定是线程安全的，例如web服务中大部分的service层。

如果这个类的方法参数中使用了对象，也是线程安全的吗？比如：

当然也是，为何？因为多线程下的使用，固然user这个对象的实例会不正常，但是对于StatelessClass这个类的对象实例来说，它并不持有UserVo的对象实例，它自己并不会有问题，有问题的是UserVo这个类，而非StatelessClass本身。

3、让类不可变

让状态不可变，加final关键字，对于一个类，所有的成员变量应该是私有的，同样的只要有可能，所有的成员变量应该加上final关键字，但是加上final，要注意如果成员变量又是一个对象时，这个对象所对应的类也要是不可变，才能保证整个类是不可变的。

但是要注意，一旦类的成员变量中有对象，上述的final关键字保证不可变并不能保证类的安全性，为何？因为在多线程下，虽然对象的引用不可变，但是对象在堆上的实例是有可能被多个线程同时修改的，没有正确处理的情况下，对象实例在堆中的数据是不可预知的。

4、加锁和CAS

最常使用的保证线程安全的手段，使用synchronized关键字，使用显式锁，使用各种原子变量，修改数据时使用CAS机制等等。

并发环境下的线程安全问题有哪些？

1、死锁

概念

是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁。

死锁的必要条件

  1. 死锁是必然发生在多操作者（M>=2个）争夺多个资源（N>=2个，且N
  2. 争夺资源的顺序不对，如果争夺资源的顺序是一样的，也不会产生死锁；
  3. 争夺者对拿到的资源不放手。

学术化的定义

死锁的发生必须具备以下四个必要条件。

  1. 互斥条件：指进程对所分配到的资源进行排它性使用，即在一段时间内某资源只由一个进程占用。如果此时还有其它进程请求资源，则请求者只能等待，直至占有资源的进程用毕释放。
  2. 请求和保持条件：指进程已经保持至少一个资源，但又提出了新的资源请求，而该资源已被其它进程占有，此时请求进程阻塞，但又对自己已获得的其它资源保持不放。
  3. 不剥夺条件：指进程已获得的资源，在未使用完之前，不能被剥夺，只能在使用完时由自己释放。
  4. 环路等待条件：指在发生死锁时，必然存在一个进程------资源的环形链，即进程集合{P0，P1，P2，···，Pn}中的P0正在等待一个P1占用的资源；P1正在等待P2占用的资源，......，Pn正在等待已被P0占用的资源。

避免死锁

理解了死锁的原因，尤其是产生死锁的四个必要条件，就可以最大可能地避免、预防和解除死锁。

只要打破四个必要条件之一就能有效预防死锁的发生。

  1. 打破互斥条件：改造独占性资源为虚拟资源，大部分资源已无法改造。
  2. 打破不可抢占条件：当一进程占有一独占性资源后又申请一独占性资源而无法满足，则退出原占有的资源。
  3. 打破占有且申请条件：采用资源预先分配策略，即进程运行前申请全部资源，满足则运行，不然就等待，这样就不会占有且申请。
  4. 打破循环等待条件：实现资源有序分配策略，对所有设备实现分类编号，所有进程只能采用按序号递增的形式申请资源。

简单顺序死锁现象

两个线程获取锁的顺序相反

java 复制代码 
public class Demo {
    public static void main(String[] args) {
        Object objA = new Object();
        Object objB = new Object();
​
        new Thread(()->{
            while(true){
                synchronized (objA){
                    //线程一
                    synchronized (objB){
                        System.out.println("小康同学正在走路");
                    }
                }
            }
        }).start();
​
        new Thread(()->{
            while(true){
                synchronized (objB){
                    //线程二
                    synchronized (objA){
                        System.out.println("小薇同学正在走路");
                    }
                }
            }
        }).start();
    }
}

**解决方法：**使用ReentranLock等工具锁，尝试获取锁，如果获取失败，则释放已经获取到的锁

java 复制代码 
public class TryLock {
    private static Lock No13 = new ReentrantLock();//第一个锁
    private static Lock No14 = new ReentrantLock();//第二个锁

    //先尝试拿No13 锁，再尝试拿No14锁，No14锁没拿到，连同No13 锁一起释放掉
    private static void zhouYuDo() throws InterruptedException {
        String threadName = Thread.currentThread().getName();
        Random r = new Random();
        while(true){
            if(No13.tryLock()){
                System.out.println(threadName +" get 13");
                try{
                    if(No14.tryLock()){
                        try{
                            System.out.println(threadName  +" get 14");
                            System.out.println("zhouYuDo do work------------");
                            break;
                        }finally{
                            No14.unlock();
                        }
                    }
                }finally {
                    No13.unlock();
                }

            }
            //Thread.sleep(r.nextInt(3));
        }
    }

    //先尝试拿No14锁，再尝试拿No13锁，No13锁没拿到，连同No14锁一起释放掉
    private static void monkeyDo() throws InterruptedException {
        String threadName = Thread.currentThread().getName();
        Random r = new Random();
        while(true){
            if(No14.tryLock()){
                System.out.println(threadName +" get 14");
                try{
                    if(No13.tryLock()){
                        try{
                            System.out.println(threadName +" get 13");
                            System.out.println("monkeyDo do work------------");
                            break;
                        }finally{
                            No13.unlock();
                        }
                    }
                }finally {
                    No14.unlock();
                }

            }
            //Thread.sleep(r.nextInt(3));
        }
    }

    private static class DemoA extends Thread{

        private String name;

        public DemoA(String name) {
            this.name = name;
        }

        public void run(){
            Thread.currentThread().setName(name);
            try {
                zhouYuDo();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        Thread.currentThread().setName("Monkey");
        DemoA demoA = new DemoA("ZhouYu");
        demoA.start();
        try {
            monkeyDo();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

动态顺序死锁

以锁作为入参，传入锁的顺序不同

java 复制代码 
public class DynDeadLock {

    private static Object No1 = new Object();//第一个锁
    private static Object No2 = new Object();//第二个锁

    /*公共业务方法*/
    private static void businessDo(Object first,Object second) throws InterruptedException {
        String threadName = Thread.currentThread().getName();
        synchronized (first){
            System.out.println(threadName + " get first");
            Thread.sleep(100);
            synchronized (second){
                System.out.println(threadName + " get second");
            }
        }
    }

        private static class DemoA extends Thread{

        private String name;

        public DemoA (String name) {
            this.name = name;
        }

        @Override
        public void run() {
            Thread.currentThread().setName(name);
            try {
                businessDo(No1,No2);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        
        Thread.currentThread().setName("A");
        DemoA demoA= new DemoA("B");
        demoA.start();
        businessDo(No2,No1);
    }

}

**解决方案：**将传入的锁进行哈希值比对，保证每次都先使用哈希值较大或者较小的锁

java 复制代码 
public class SafeOperate {

    private static Object No13 = new Object();//第一个锁
    private static Object No14 = new Object();//第二个锁
    private static Object tieLock = new Object();//第三把锁

    public void transfer(Object first,Object second)
            throws InterruptedException {

        int firstHash = System.identityHashCode(first);
        int secondHash = System.identityHashCode(second);

        if(firstHash<secondHash){
            synchronized (first){
                System.out.println(Thread.currentThread().getName()+" get "+first);
                Thread.sleep(100);
                synchronized (second){
                    System.out.println(Thread.currentThread().getName()+" get "+second);
                }
            }
        }else if(secondHash<firstHash){
            synchronized (second){
                System.out.println(Thread.currentThread().getName()+" get"+second);
                Thread.sleep(100);
                synchronized (first){
                    System.out.println(Thread.currentThread().getName()+" get"+first);
                }
            }
        }else{
            synchronized (tieLock){
                synchronized (first){
                    synchronized (second){
                        System.out.println(Thread.currentThread().getName()+" get"+first);
                        System.out.println(Thread.currentThread().getName()+" get"+second);
                    }
                }
            }
        }
    }
}

2、活锁

两个线程在尝试拿锁的机制中，发生多个线程之间互相谦让，不断发生同一个线程总是拿到同一把锁，在尝试拿另一把锁时因为拿不到，而将本来已经持有的锁释放的过程。

**解决方式：**每个线程休眠随机数，错开拿锁的时间。

3、线程饥饿

一个线程由于优先级太低，始终得不到 CPU 调度执行，也不能够结束

相关推荐
群联云防护小杜6 分钟前
服务器被攻击怎么办
运维·服务器·网络·网络协议·安全·web安全
利哥AI实例探险15 分钟前
建筑工地AI安全检测系统：YOLO11数据标注训练与PyQt5界面设计应用开发
人工智能·qt·安全
安胜ANSCEN26 分钟前
数据流动背后的“暗流涌动”，企业如何借助多源威胁检测响应高效捕捉安全威胁？
安全
raysync8882 小时前
替代传统FTP传输，镭速大数据传输系统实现安全高效数据流转！
开发语言·安全·php
网络安全（king）2 小时前
网络安全之接入控制
网络·学习·安全·web安全
鱼大大博客2 小时前
Edge Scdn是用来干什么的？
网络·安全·edge
云云3214 小时前
云手机：Facebook多账号管理的创新解决方案
服务器·线性代数·安全·智能手机·架构·facebook
?333335 小时前
CTFHub Web进阶-PHP-Bypass disable_function攻略
开发语言·安全·web安全·php
热门推荐
01大模型国产化适配7-华为昇腾LLM落地可选解决方案（MindFormers、ModelLink、MindIE）02Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO03玄机平台应急响应—webshell查杀04电赛2024年H题智能小车基于MSPM0G3507主控MCU（利用8路灰度加上MPU6050的解决方式）具体项目报告05组基轨迹建模 GBTM的介绍与实现（Stata 或 R）06支付宝短视频平台创作分成激励项目07怎么找小红书美食探店博主合作？08【一文读懂】NTN（非地面网络）技术介绍09优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间10校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站