技术自查番外篇六：死锁及解决办法

最新推荐文章于 2024-07-10 21:37:49 发布
最新推荐文章于 2024-07-10 21:37:49 发布
阅读量1.8k 收藏 2
点赞数
分类专栏： 多线程 线程 jvm 文章标签： java 线程安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/banbeisudashui/article/details/120570494
版权
jvm 同时被 3 个专栏收录
12 篇文章 0 订阅
订阅专栏
多线程
5 篇文章 0 订阅
订阅专栏
线程
5 篇文章 0 订阅
订阅专栏

前言

线程的六种状态（初始，等待，阻塞，运行，就绪和等待），我们都知道，但实际情况下，会出现这六种状态下的，第七种情况死锁，那么死锁是什么，为什么会发生呢？

先了解下死锁的概念

概念

两个线程同一时间持有自身的锁且互相争夺对方的锁，等待对方锁释放，如果没有外力介入下，这两个线程会一直等待下去。

虽然说一直等待，可以说是等待状态，但由于它们互相持有对方所需的锁，此时就是阻塞状态了。

发生死锁条件

1. 互斥条件

2. 持有并等待状态（持有本身锁且等待对方锁）

3. 不可剥夺条件（不可释放本身锁）

4. 环路等待状态（死循环）

栗子

/**
 * @author Leo
 * @description
 * @createDate 2021/8/30 22:22
 **/
public class MyLock {
    public static Object obj1 = new Object();
    public static Object obj2 = new Object();
}

/**
 * @author Leo
 * @description
 * @createDate 2021/8/30 22:21
 **/
public class DieLock implements Runnable {

    private boolean flag;

    public DieLock(boolean flag) {
        this.flag = flag;
    }

    @Override
    public void run() {
        if (flag) {
            while (true) {
                synchronized (MyLock.obj1) {
                    System.out.println(Thread.currentThread().getName() + "....if...obj1..." + flag);
                    synchronized (MyLock.obj2) {
                        System.out.println(Thread.currentThread().getName() + ".....if.....obj2....." + flag);

                    }
                }
            }
        } else {
            while (true) {
                synchronized (MyLock.obj2) {
                    System.out.println(Thread.currentThread().getName() + "....else...obj2..." + flag);
                    synchronized (MyLock.obj1) {
                        System.out.println(Thread.currentThread().getName() + ".....else.....obj1....." + flag);

                    }
                }
            }
        }

    }
}

/**
 * @author Leo
 * @description
 * @createDate 2021/9/4 21:16
 **/
public class DieDemo {

    public static void main(String[] args) {
        DieLock d1 = new DieLock(true);
        DieLock d2 = new DieLock(false);
        Thread t1 = new Thread(d1);
        Thread t2 = new Thread(d2);
        t1.start();
        t2.start();
    }

}
运行结果：
Thread-0....if...obj1...true
Thread-1....else...obj2...false

栗子2

/**
 * @author Leo
 * @description lock版死锁
 * @createDate 2021/9/16 23:13
 **/
public class DieLockLock {
    public static void main(String[] args) {
        
        Lock lockA = new ReentrantLock(); // 创建锁 A
        Lock lockB = new ReentrantLock(); // 创建锁 B

        // 创建线程 1
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                lockA.lock(); // 加锁
                System.out.println("线程 1:获取到锁 A!");
                try {
                    Thread.sleep(1000);
                    System.out.println("线程 1:等待获取 B...");
                    lockB.lock(); // 加锁
                    try {
                        System.out.println("线程 1:获取到锁 B!");
                    } finally {
                        lockB.unlock(); // 释放锁
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lockA.unlock(); // 释放锁
                }
            }
        });
        t1.start(); // 运行线程

        // 创建线程 2
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                lockB.lock(); // 加锁
                System.out.println("线程 2:获取到锁 B!");
                try {
                    Thread.sleep(1000);
                    System.out.println("线程 2:等待获取 A...");
                    lockA.lock(); // 加锁
                    try {
                        System.out.println("线程 2:获取到锁 A!");
                    } finally {
                        lockA.unlock(); // 释放锁
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lockB.unlock(); // 释放锁
                }
            }
        });
        t2.start(); // 运行线程
    }
}
日志
线程 1:获取到锁 A!
线程 2:获取到锁 B!
线程 1:等待获取 B...
线程 2:等待获取 A...

从上面栗子可知

1. 互斥条件

t1,t2线程分别持有d1,d2锁，同时又想获取对方的锁，由于锁的互斥性，导致同一个锁同一时间不可被多个线程持有

2. 持有并等待状态、不可剥夺状态

t1,t2线程分别持有d1,d2锁，同时又想获取对方的锁，由于锁的互斥性，同时加上本身自身逻辑问题，又不能释放本身锁，这就导致最后两个线程互相持有本身锁，处于等待状态和不可剥夺状态

3.  环路等待状态

刚才也说过，t1等待d2，t2等待d1，形成死循环

 如何排查线程问题

答案：使用java自带的jstack工具，分析项目的线程日志，jstack工具如何使用，该篇文章已介绍过《技术自查番外篇四：Jstack与线程》

如何解决死锁

刚才也提到死锁的四个条件，只要打破任意一条件，解决起来就容易。

大体分为两种方法

1. 资源有序分配法（适用于synchronize和lock）

2. 轮询法（仅适用于lock）

一、资源有序分配法

简单概括：线程之间保证获取锁的顺序是一致。例如：线程A和线程B，以同样的顺序获取锁A和锁B（适用于synchronize和lock，这里以synchronize为实例）

示例代码

/**
 * @author Leo
 * @description
 * @createDate 2021/9/4 21:16
 **/
public class DieDemo {

    public static void main(String[] args) {
        DieLock d1 = new DieLock();
        DieLock d2 = new DieLock();
        Thread t1 = new Thread(d1);
        Thread t2 = new Thread(d2);
        t1.start();
        t2.start();
    }

}
/**
 * @author Leo
 * @description
 * @createDate 2021/8/30 22:21
 **/
public class DieLock implements Runnable {

    @Override
    public void run() {
        while (true) {
            synchronized (MyLock.obj1) {
                System.out.println(Thread.currentThread().getName() + "....if...obj1..." );
                synchronized (MyLock.obj2) {
                    System.out.println(Thread.currentThread().getName() + ".....if.....obj2....." );

                }
            }
        }
    }
}
/**
 * @author Leo
 * @description
 * @createDate 2021/8/30 22:22
 **/
public class MyLock {
    public static Object obj1 = new Object();
    public static Object obj2 = new Object();
}
日志
Thread-0....if...obj1...
Thread-0.....if.....obj2.....
Thread-0....if...obj1...
Thread-0.....if.....obj2.....
Thread-0....if...obj1...
Thread-0.....if.....obj2.....
Thread-0....if...obj1...
Thread-0.....if.....obj2.....
Thread-0....if...obj1...
Thread-0.....if.....obj2.....
Thread-0....if...obj1...
Thread-0.....if.....obj2.....
Thread-0....if...obj1...
Thread-0.....if.....obj2.....
Thread-0....if...obj1...
Thread-0.....if.....obj2.....
Thread-0....if...obj1...
Thread-0.....if.....obj2.....
Thread-0....if...obj1...
Thread-0.....if.....obj2.....
Thread-0....if...obj1...
Thread-0.....if.....obj2.....
Thread-0....if...obj1...
Thread-0.....if.....obj2.....
Thread-0....if...obj1...
Thread-0.....if.....obj2.....
Thread-0....if...obj1...
................

二、轮询法

简单概括：轮询获取锁的状态（仅支持lock）

因为lock支持非阻塞式获取锁，所以轮询法仅支持lock

/**
 * @author Leo
 * @description lock版 trylock 优化版2，轮询
 * @createDate 2021/9/16 23:13
 **/
public class NoDieLockLock2 {

    public static void main(String[] args) {
        Lock lockA = new ReentrantLock(); // 创建锁 A
        Lock lockB = new ReentrantLock(); // 创建锁 B

        // 创建线程 1(使用轮询锁)
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 调用轮询锁
                pollingLock(lockA, lockB);
            }
        });
        t1.start(); // 运行线程

        // 创建线程 2
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                lockB.lock(); // 加锁
                System.out.println("线程 2:获取到锁 B!");
                try {
                    Thread.sleep(1000);
                    System.out.println("线程 2:等待获取 A...");
                    lockA.lock(); // 加锁
                    try {
                        System.out.println("线程 2:获取到锁 A!");
                    } finally {
                        lockA.unlock(); // 释放锁
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    // 线程 2 忘记释放锁资源
                    // lockB.unlock(); // 释放锁
                }
            }
        });
        t2.start(); // 运行线程
    }

    /**
     * 轮询锁
     * <p>
     */
    public static void pollingLock(Lock lockA, Lock lockB) {
        // 轮询次数计数器
        while (true) {
            if (lockA.tryLock()) { // 尝试获取锁
                System.out.println("线程 1:获取到锁 A!");
                try {
                    Thread.sleep(1000);
                    System.out.println("线程 1:等待获取 B...");
                    if (lockB.tryLock()) { // 尝试获取锁
                        try {
                            System.out.println("线程 1:获取到锁 B!");
                        } finally {
                            lockB.unlock(); // 释放锁
                            System.out.println("线程 1:释放锁 B.");
                            break;
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lockA.unlock(); // 释放锁
                    System.out.println("线程 1:释放锁 A.");
                }
            }

            // 等待一秒再继续尝试获取锁
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

上述代码由于trylock会一致轮询锁的状态，这样也会造成很大的资源开销，为了解决这问题，我们可以优化下，加个最大的轮询次数

优化1

/**
 * @author Leo
 * @description lock版 trylock 优化版1，轮询加次数限制
 * @createDate 2021/9/16 23:13
 **/
public class NoDieLockLock2 {

    public static void main(String[] args) {
        Lock lockA = new ReentrantLock(); // 创建锁 A
        Lock lockB = new ReentrantLock(); // 创建锁 B

        // 创建线程 1(使用轮询锁)
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 调用轮询锁
                pollingLock(lockA, lockB, 3);
            }
        });
        t1.start(); // 运行线程

        // 创建线程 2
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                lockB.lock(); // 加锁
                System.out.println("线程 2:获取到锁 B!");
                try {
                    Thread.sleep(1000);
                    System.out.println("线程 2:等待获取 A...");
                    lockA.lock(); // 加锁
                    try {
                        System.out.println("线程 2:获取到锁 A!");
                    } finally {
                        lockA.unlock(); // 释放锁
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    // 线程 2 忘记释放锁资源
                    // lockB.unlock(); // 释放锁
                }
            }
        });
        t2.start(); // 运行线程
    }

    /**
     * 轮询锁
     * <p>
     * maxCount：最大轮询次数
     */
    public static void pollingLock(Lock lockA, Lock lockB, int maxCount) {
        // 轮询次数计数器
        int count = 0;
        while (true) {
            if (lockA.tryLock()) { // 尝试获取锁
                System.out.println("线程 1:获取到锁 A!");
                try {
                    Thread.sleep(1000);
                    System.out.println("线程 1:等待获取 B...");
                    if (lockB.tryLock()) { // 尝试获取锁
                        try {
                            System.out.println("线程 1:获取到锁 B!");
                        } finally {
                            lockB.unlock(); // 释放锁
                            System.out.println("线程 1:释放锁 B.");
                            break;
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lockA.unlock(); // 释放锁
                    System.out.println("线程 1:释放锁 A.");
                }
            }

            // 判断是否已经超过最大次数限制
            if (count++ > maxCount) {
                // 终止循环
                System.out.println("轮询锁获取失败,记录日志或执行其他失败策略");
                return;
            }

            // 等待一秒再继续尝试获取锁
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

优化2，轮询+次数+随机时间

/**
 * @author Leo
 * @description lock版 trylock 优化版4，轮询加次数限制 + 随机睡眠时间
 * @createDate 2021/9/16 23:13
 **/
public class NoDieLockLock4 {

    private static Random rdm = new Random();

    public static void main(String[] args) {
        Lock lockA = new ReentrantLock(); // 创建锁 A
        Lock lockB = new ReentrantLock(); // 创建锁 B

        // 创建线程 1(使用轮询锁)
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 调用轮询锁
                pollingLock(lockA, lockB, 3);
            }
        });
        t1.start(); // 运行线程

        // 创建线程 2
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                lockB.lock(); // 加锁
                System.out.println("线程 2:获取到锁 B!");
                try {
                    Thread.sleep(1000);
                    System.out.println("线程 2:等待获取 A...");
                    lockA.lock(); // 加锁
                    try {
                        System.out.println("线程 2:获取到锁 A!");
                    } finally {
                        lockA.unlock(); // 释放锁
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    // 线程 2 忘记释放锁资源
                    // lockB.unlock(); // 释放锁
                }
            }
        });
        t2.start(); // 运行线程
    }

    /**
     * 轮询锁
     * <p>
     * maxCount：最大轮询次数
     */
    public static void pollingLock(Lock lockA, Lock lockB, int maxCount) {
        // 轮询次数计数器
        int count = 0;
        while (true) {
            if (lockA.tryLock()) { // 尝试获取锁
                System.out.println("线程 1:获取到锁 A!");
                try {
                    Thread.sleep(1000);
                    System.out.println("线程 1:等待获取 B...");
                    if (lockB.tryLock()) { // 尝试获取锁
                        try {
                            System.out.println("线程 1:获取到锁 B!");
                        } finally {
                            lockB.unlock(); // 释放锁
                            System.out.println("线程 1:释放锁 B.");
                            break;
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lockA.unlock(); // 释放锁
                    System.out.println("线程 1:释放锁 A.");
                }
            }

            // 判断是否已经超过最大次数限制
            if (count++ > maxCount) {
                // 终止循环
                System.out.println("轮询锁获取失败,记录日志或执行其他失败策略");
                return;
            }

            // 等待一秒再继续尝试获取锁
            try {
                Thread.sleep(300 + rdm.nextInt(8) * 100); // 固定时间 + 随机时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

熊猫有几种颜色
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程死锁及解决办法
SilverTabby的博客
02-05 4632
什么是死锁 多线程以及多进程改善了系统资源的利用率并提高了系统的处理能力。然而为了保证同步，也会引入锁机制，并发执行也带来了新的问题–死锁。 所谓死锁是指多个线程因竞争资源而造成的一种僵局（互相等待），若无外力作用，这些进程都将无法向前推进。 死锁产生的必要条件 以下这四个条件是死锁的必要条件，只要系统发生死锁，这些条件必然成立，而只要上述条件之一不满足，就不会发生死锁。 互斥条件 进程要求对...
408 考研《操作系统》第二章第七节：死锁和死锁的三种处理策略（预防死锁、避免死锁、检测和解除）
123加油的博客
12-13 957
在并发环境下，各进程因竞争资源而造成的一种互相等待对方手里的资源，导致各进程都阻塞,都无法向前推进的现象，就是“死锁”。发生死锁后若无外力干涉,这些进程都将无法向前推进。互斥条件：只有对必须互斥使用的资源的争抢才会导致死锁。如果把只能互斥使用的资源改造为允许共享使用，则系统不会进入死锁状态。比如:SPOOLing技术。操作系统可以采用 SPOOLing 技术把独占设备在逻辑上改造成共享设备。比如，用SPOOLing技术将打印机改造为共享设备…该策略的缺点。
死锁的处理策略
PABL01的博客
11-18 718
预防死锁、避免死锁、检测和处理死锁
操作系统死锁
研究僧只干活不吃饭
02-23 542
deadlocks（死锁）　　 所谓死锁: 是指两个或两个以上的进程在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,它们都将无法推进下去.此时称系统处于死锁状态或系统产生了死锁,这些永远在互相等竺的进程称为死锁进程. 　　由于资源占用是互斥的，当某个进程提出申请资源后，使得有关进程在无外力协助下，永远分配不到必需的资源而无法继续运行，这就产生了一种特殊现象死锁。 　　一种
多线程学习（三）
qq_41403171的博客
11-06 1330
本文介绍了什么是死锁，以及产生死锁的条件和如何预防和避免死锁，介绍了两种算法，分别是有序资源分配法和银行家算法，复习线程同步内容，用代码实现生产者消费者问题。
有序资源分配法
骐骥一跃，不能十步；驽马十驾，功在不舍。
09-24 9310
是操作系统中预防死锁的一种算法，这种算法资源按某种规则系统中的所有资源统一编号（例如打印机为1、磁带机为2、磁盘为3、等等），申请时必须以上升的次序。 系统要求申请进程： 1、对它所必须使用的而且属于同一类的所有资源，必须一次申请完； 2、在申请不同类资源时，必须按各类设备的编号依次申请。 例如：进程PA，使用资源的顺序是R1，R2； 进程PB，使用资源的顺序是R2，R1； 若采用动态分配有可能形...
大家都来学 Java（四）操作系统问题总结
立志Java全栈的伦哥哥
05-12 413
操作系统 操作系统部分主要考查一些与写项目过程中息息相关的理论知识。 1. 死锁 所谓死锁: 是指两个或两个以上的进程在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,它们都将无法推进下去.此时称系统处于死锁状态或系统产生了死锁,这些永远在互相等待的进程称为死锁进程. 产生死锁的原因主要是： （1） 因为系统资源不足。 （2） 进程运行推进的顺序不合适。 （3） 资源分配不当等。 　　 如果系统资源充足，进程的资源请求都能够得到满足，死锁出现的可能性就很低，否则就会因争夺有限的资源而陷入死锁
操作系统（五）死锁
李思净的博客
10-13 846
死锁死锁的产生死锁的定义死锁产生的原因资源的概念死锁的例子死锁产生的必要条件死锁预防死锁预防的概念资源的静态分配策略资源的有序分配法死锁避免死锁避免的概念安全状态与安全序列银行家算法死锁的检测与解除死锁检测的时机死锁检测的算法死锁的解除方法资源分配图资源分配图死锁定理资源分配图化简方法哲学家就餐问题 死锁的产生 死锁的定义 死锁产生的原因 资源的概念 死锁的例子 死锁产生的必要条件 互斥条件 不...
记一次公司仓库数据库服务器死锁过程及解决办法
09-10
数据库死锁是数据库管理系统中常见的问题，特别是在并发操作频繁的环境中。死锁发生时，两个或多个事务在执行过程中，因争夺资源而造成的一种相互等待的现象，若无外力干涉它们将无法继续执行。理解死锁的四个必要...
mysql 数据库死锁原因及解决办法
09-10
解决死锁的方法： 1. **死锁预防**：设计系统时，确保以上四个条件之一不成立。例如，通过预设资源分配策略，避免进程永久占有资源，或者设置资源获取顺序，避免循环等待。 2. **死锁避免**：在事务执行前进行资源...
哲学家就餐问题
12-22
哲学家就餐问题与死锁。该程序能演示哲学家死锁情况，也能演示采用死锁预防方法解除死锁的情况 （1）演示死锁现象； （2）通过资源预分配法防止死锁； （3）退出。
Java线程死锁实例及解决方法
08-25
Java线程死锁实例及解决方法 Java线程死锁是一种特殊的线程状态，发生死锁时，多个线程会相互等待，无法继续执行，直到外部干预。下面是Java线程死锁实例及解决方法的详细介绍。 一、死锁的定义 所谓死锁是指多个...
实验二：死锁的检测和预防.doc
10-10
实验二：死锁的检测和预防 在操作系统中，死锁是指两个或多个进程在竞争资源时，因资源分配不当而互相等待对方释放资源，从而导致所有进程都无法继续执行的现象。为了避免死锁的发生，需要对进程的资源申请和分配...
资源分配与调度
weixin_43840862的博客
12-31 8897
1 资源管理概述 1.1 资源管理的目的和任务 目的： 1、保证资源的高利用率； 2、在“合理”时间内使所有顾客有获得所需资源的机会； 3、对不可共享的资源实施互斥使用； 4、防止由资源分配不当而引起的死锁。 对资源的管理应包括以下几个方面： 1、资源管理的描述－－数据结构 2、确定资源的分配原则和调度原则 3、执行资源分配（实施） 4、存取控制和安全保护 1.2 资源的几种分类方法 （一）物理资...
采用有序分配法预防死锁的哲学家就餐问题
m0_47354330的博客
01-14 3051
1 设计目的 理解死锁的概念，掌握死锁预防方法。 死锁是进程并发执行过程中可能出现的现象，哲学家就餐问题是描述死锁的经典例子。 为了防止死锁，可以采用资源有序分配法。资源有序分配法是指事先将所有资源类全排序, 即赋予每一个资源类一个唯一的整数，规定进程必需按照资源编号由小到大的次序申请资源。 在哲学家就餐问题中，要采用资源有序分配法只需规定每个哲学家先申请左右两根筷子中编号小的筷子，再申请编号大的筷子。 2 设计要求 利用多线程技术编写哲学家就餐程序，演示采用死锁防止方法后不产生死锁的情况。 3 设计
操作系统原理第五章（资源分配与调度）
coderxsj
06-15 7942
一、资源管理             1.资源的动态分配：进程所需的资源是在进程运行中根据运行情况动态的分配、使用和释放的。                        静态分配：批处理操作系统中，对作业一级采用资源静态分配方法。作业所需要的资源是在调度到这个作业的时候，根据用户给出的信息进行分配，并在做作业运行完毕后释放所获得的的全部资源。          2.资源管理任务：        ...
死锁以及处理策略
Jay的博客
09-15 454
什么是死锁？ 所谓死锁，是指多个进程在运行过程中因争夺资源而造成的一种僵局，当进程处于这种僵持状态时，若无外力作用，它们都将无法再向前推进。 因此我们举个例子来描述，如果此时有一个线程A，按照先锁a再获得锁b的的顺序获得锁，而在此同时又有另外一个线程B，按照先锁b再锁a的顺序获得锁。如下图所示： 产生死锁的原因？ 可归结为如下两点： a. 竞争资源 系统中的资源可以分为两类： 可剥夺资源，是指某进程在获得这类资源后，该资源可以再被其他进程或系统剥夺，CPU和主存均属于可剥夺性资源； 另一类资源是不可剥夺资
配置Java开发环境
最新发布
Broken_x的博客
07-10 1586
Java开发环境配置
java中的并发变成学习笔记3
05-27
总的来说，死锁是Java多线程编程中一个需要警惕和解决的严重问题。通过理解死锁产生的原因和必备条件，以及遵守一些编程技巧和原则，可以有效地避免死锁的发生，确保多线程程序的稳定和可靠性。希望本文对大家理解和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值