2.20、哲学家进餐问题

于 2023-02-13 00:12:29 发布
阅读量1.2k 收藏 15
点赞数 1
分类专栏： 操作系统 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_67720621/article/details/129001990
版权

一张圆桌上坐着 5 名哲学家，每两个哲学家之间的桌上摆一根筷子，桌子的中间是一碗米饭。

哲学家们倾注毕生的精力用于思考和进餐，哲学家在思考时，并不影响他人。

只有当哲学家饥饿时，才试图拿起左、右两根筷子（一根一根地拿起)。如果筷子已在他人手上，则需等待。

饥饿的哲学家只有同时拿起两根筷子才可以开始进餐，当进餐完毕后，放下筷子继续思考。

image-20230204003023792

1、问题分析

  1. 关系分析。系统中有5个哲学家进程，5位哲学家与左右邻居对其中间筷子的访问是互斥关系。

  2. 整理思路。这个问题中只有互斥关系，但与之前遇到的问题不同的事，每个哲学家进程需要同时持有两个临界资源才能开始吃饭。如何避免临界资源分配不当造成的死锁现象，是哲学家问题的精髓。

  3. 信号量设置。定义互斥信号量数组 chopstick[5]={1,1,1,1,1} 用于实现对 5 个筷子的互斥访问。

    并对哲学家按 0~4 编号，哲学家i左边的筷子编号为 i ，右边的筷子编号为 (i+1)%5。

错误

image-20230204003436560

循环的等待

2、如何避免死锁的发生呢？（附 Java 实现）

① 可以对哲学家进程施加一些限制条件，比如最多允许四个哲学家同时进餐。（破坏循环等待条件，本来 5 个哲学家对应 5 个筷子，现在 4 个哲学家对应 5 个筷子）

这样可以保证至少有一个哲学家是可以拿到左右两只筷子的

image-20230204003718420

semaphore chopstick [5] = {1,1,1,1,1};
semaphore mutex = 4; //只允许 4 个哲学家进行争抢
pi () {
    while (1) {
        P(mutex);
        P(chopstick[i]);			//拿左
        P(chopstick[(i + 1) % 5]);  //拿右
        V(mutex);					//V 顺序无所谓
        吃饭...
        V(chopstick[i]);			//放左
        V(chopstick[(i + 1) % 5]);  //放右
        思考...
    }
}

Java 实现

/**
 * 最多允许四个哲学家同时进餐
 */
class DiningPhilosophers {

    public DiningPhilosophers() {

    }

    Lock[] chopstick = new ReentrantLock[]{
            new ReentrantLock(),
            new ReentrantLock(),
            new ReentrantLock(),
            new ReentrantLock(),
            new ReentrantLock()
    };
    Semaphore mutex = new Semaphore(4);

    // call the run() method of any runnable to execute its code
    public void wantsToEat(int philosopher,
                           Runnable pickLeftFork,
                           Runnable pickRightFork,
                           Runnable eat,
                           Runnable putLeftFork,
                           Runnable putRightFork) throws InterruptedException {
        //信号量 -1
        mutex.acquire();
        //拿起左右筷子
        chopstick[philosopher].lock();
        chopstick[(philosopher + 1) % 5].lock();
        pickLeftFork.run();
        pickRightFork.run();
        //eat
        eat.run();
        //放下左右筷子
        putLeftFork.run();
        putRightFork.run();
        chopstick[philosopher].unlock();
        chopstick[(philosopher + 1) % 5].unlock();
        //信号量 + 1
        mutex.release();
    }
}

② 要求奇数号哲学家先拿左边的筷子，然后再拿右边的筷子，而偶数号哲学家刚好相反。（破坏循环等待，分为奇偶数，给上编号）

用这种方法可以保证如果相邻的两个奇偶号哲学家都想吃饭,那么只会有其中一个可以拿起第一只筷子，另一个会直接阻塞。这就避免了占有一支后再等待另一只的情况。

semaphore chopstick [5] = {1,1,1,1,1};
semaphore mutex = 1; //互斥地取筷子
pi () {
    while (1) {
        P(mutex);
        //偶数
        if (i & 1 == 0) {
	        P(chopstick[(i + 1) % 5]);  //拿右   
	        P(chopstick[i]);			//拿左
        }else {
            P(chopstick[i]);			//拿左
	        P(chopstick[(i + 1) % 5]);  //拿右   
        }
        V(mutex);					//V 顺序无所谓
        吃饭...
        V(chopstick[i]);			//放左
        V(chopstick[(i + 1) % 5]);  //放右
        思考...
    }
}

image-20230204004009243

Java 实现

/**
 * 奇数号哲学家先左后右, 偶数号哲学家先右后左
 */
class DiningPhilosophers {

    public DiningPhilosophers() {

    }

    Lock[] chopstick = new ReentrantLock[]{
            new ReentrantLock(),
            new ReentrantLock(),
            new ReentrantLock(),
            new ReentrantLock(),
            new ReentrantLock()
    };

    // call the run() method of any runnable to execute its code
    public void wantsToEat(int philosopher,
                           Runnable pickLeftFork,
                           Runnable pickRightFork,
                           Runnable eat,
                           Runnable putLeftFork,
                           Runnable putRightFork) throws InterruptedException {
        //尝试拿起左右筷子
        if ((philosopher & 1) != 0) {
            chopstick[philosopher].lock();
            chopstick[(philosopher + 1) % 5].lock();
        }else {
            chopstick[(philosopher + 1) % 5].lock();
            chopstick[philosopher].lock();
        }

        pickLeftFork.run();
        pickRightFork.run();
        //eat
        eat.run();
        putLeftFork.run();
        putRightFork.run();
        //放下左右筷子
        chopstick[philosopher].unlock();
        chopstick[(philosopher + 1) % 5].unlock();
    }
}

③ 仅当一个哲学家左右两支筷子都可用时才允许他抓起筷子。（破坏请求和保持条件，预先分配 2 个筷子）

如下所示：

  1. 若 0 号哲学家正在 P(chopstick[i]) 中，此时 2 号哲学家也想拿筷子，将会阻塞在 P(mutex) ，直到等待 0 号哲学家 V(mutex)

  2. 若 0 号哲学家正在吃饭，0, 1 号筷子被使用；此时 1 号哲学家将会阻塞 P(chopstick[i]);（0 号筷子）， mutex = 0; 若 2 号哲学家也想拿筷子，则会被阻塞到 P(mutex)

    • 即使 2 号左右两边的筷子都在，也暂时无法取得

  3. 若 0 号哲学家正在吃饭，0, 1 号筷子被使用；此时 4 号哲学家将拿起左边筷子，但是阻塞在 P(chopstick[(i + 1) % 5]) ，直到等待 0 号哲学家吃完饭 V(chopstick[i]);

    • 此时 4 号右边的筷子不可用，但 4 号仍然会拿起左边的筷子
semaphore chopstick [5] = {1,1,1,1,1};
semaphore mutex =1; //互斥地取筷子
Pi () {				//i 号哲学家的进程
	while (1) {
        P(mutex);
        P(chopstick[i]);			//拿左
        P(chopstick[(i + 1) % 5]);  //拿右
        V(mutex);
        吃饭...
        V(chopstick[i]);			//放左
        V(chopstick[(i + 1) % 5]);  //放右
        思考...
    }	
}

因此上述方法并不能保证只有两边的筷子都可用时，才允许哲学家拿起筷子

  • 例如上述的情况 1 和 2 都会导致 2 号哲学家两边的筷子都可以用，但是却被阻塞

更准确的说法应该是：

  • 各哲学家拿筷子这件事必须互斥的执行。

    这就保证了即使一个哲学家在拿筷子拿到一半时被阻塞，也不会有别的哲学家会继续尝试拿筷子。

    这样的话，当前正在吃饭的哲学家放下筷子后,被阻塞的哲学家就可以获得等待的筷子了。

Java 实现

class DiningPhilosophers {

    public DiningPhilosophers() {

    }

    Lock[] chopstick = new ReentrantLock[]{
            new ReentrantLock(),
            new ReentrantLock(),
            new ReentrantLock(),
            new ReentrantLock(),
            new ReentrantLock()
    };
    Lock mutex = new ReentrantLock();

    // call the run() method of any runnable to execute its code
    public void wantsToEat(int philosopher,
                           Runnable pickLeftFork,
                           Runnable pickRightFork,
                           Runnable eat,
                           Runnable putLeftFork,
                           Runnable putRightFork) throws InterruptedException {

        //由于要同时持有,所以要互斥
        mutex.lock();
        chopstick[philosopher].lock();
        chopstick[(philosopher + 1) % 5].lock();
        mutex.unlock();

        pickLeftFork.run();
        pickRightFork.run();
        //eat
        eat.run();
        putLeftFork.run();
        putRightFork.run();
        //放下左右筷子
        chopstick[philosopher].unlock();
        chopstick[(philosopher + 1) % 5].unlock();
    }
}

3、位运算 + CAS 优化

方式① 最多允许四个哲学家同时进餐

/**
 * 最多允许四个哲学家同时进餐
 */
class DiningPhilosophers {

    public DiningPhilosophers() {

    }

    //若 chopstick 等于 0, 表示筷子未被使用
    AtomicInteger chopstick = new AtomicInteger();
    // 00001, 00010, 00100, 01000, 10000
    int[] chopstickMask = new int[]{1, 2, 4, 8, 16};

    Semaphore mutex = new Semaphore(4);

    // call the run() method of any runnable to execute its code
    public void wantsToEat(int philosopher,
                           Runnable pickLeftFork,
                           Runnable pickRightFork,
                           Runnable eat,
                           Runnable putLeftFork,
                           Runnable putRightFork) throws InterruptedException {
        //左右筷子
        int leftC = chopstickMask[philosopher];
        int rightC = chopstickMask[(philosopher + 1) % 5];
        //信号量 -1
        mutex.acquire();
        //尝试拿起左右筷子
        //CAS
        while (!get(leftC)) {
            Thread.sleep(1);
        }
        while (!get(rightC)) {
            Thread.sleep(1);
        }
        pickLeftFork.run();
        pickRightFork.run();
        //eat
        eat.run();
        putLeftFork.run();
        putRightFork.run();
        //放下左右筷子
        while (!put(leftC)) {
            Thread.sleep(1);
        }
        while (!put(rightC)) {
            Thread.sleep(1);
        }

        //信号量 + 1
        mutex.release();
    }

    private boolean put(int mask) {
        int expect = chopstick.get();
        //例如：1 号放下筷子 00001 和 00010
        // 左边的筷子 expect : 00011 ^ 00001 -> 00010
        // 右边的筷子 expect : 00010 ^ 00010 -> 00000
        return chopstick.compareAndSet(expect, expect ^ mask);
    }

    //尝试拿起左右筷子
    private boolean get(int mask) {
        int expect = chopstick.get();
        //只有当前筷子没有被拿起才返回 true, 并且更新筷子状态
        // 例如：1 号拿起筷子 00001 和 00010 , 更新后 : 00011 (说明1, 2号筷子被拿了)
        //  此时 2 号想拿起左边的筷子 : 00010 , & 运算发现被拿了, 返回false
        return (expect & mask) <= 0 && chopstick.compareAndSet(expect, expect ^ mask);
    }
}

方式② 奇数号哲学家先左后右, 偶数号哲学家先右后左

import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 奇数号哲学家先左后右, 偶数号哲学家先右后左
 */

class DiningPhilosophers {

    public DiningPhilosophers() {

    }

    //若 chopstick 等于 0, 表示筷子未被使用
    AtomicInteger chopstick = new AtomicInteger();
    // 00001, 00010, 00100, 01000, 10000
    int[] chopstickMask = new int[]{1, 2, 4, 8, 16};


    // call the run() method of any runnable to execute its code
    public void wantsToEat(int philosopher,
                           Runnable pickLeftFork,
                           Runnable pickRightFork,
                           Runnable eat,
                           Runnable putLeftFork,
                           Runnable putRightFork) throws InterruptedException {
        //左右筷子
        int leftC = chopstickMask[philosopher];
        int rightC = chopstickMask[(philosopher + 1) % 5];
        //信号量 -1
        if ((philosopher & 1) != 0) {
            //尝试拿起左右筷子
            while (!get(leftC)) {
                Thread.sleep(1);
            }
            while (!get(rightC)) {
                Thread.sleep(1);
            }
        } else {
            //尝试拿起右左筷子
            while (!get(rightC)) {
                Thread.sleep(1);
            }
            while (!get(leftC)) {
                Thread.sleep(1);
            }

        }

        //退出临界区

        pickLeftFork.run();
        pickRightFork.run();
        //eat
        eat.run();
        putLeftFork.run();
        putRightFork.run();
        //放下左右筷子
        while (!put(leftC)) {
            Thread.sleep(1);
        }
        while (!put(rightC)) {
            Thread.sleep(1);
        }
        //信号量 + 1
    }

    private boolean put(int mask) {
        int expect = chopstick.get();
        //例如：1 号放下筷子 00001 和 00010
        // 左边的筷子 expect : 00011 ^ 00001 -> 00010
        // 右边的筷子 expect : 00010 ^ 00010 -> 00000
        return chopstick.compareAndSet(expect, expect ^ mask);
    }

    //尝试拿起左右筷子
    private boolean get(int mask) {
        int expect = chopstick.get();
        //只有当前筷子没有被拿起才返回 true, 并且更新筷子状态
        // 例如：1 号拿起筷子 00001 和 00010 , 更新后 : 00011 (说明1, 2号筷子被拿了)
        //  此时 2 号想拿起左边的筷子 : 00010 , & 运算发现被拿了, 返回false
        return (expect & mask) <= 0 && chopstick.compareAndSet(expect, expect ^ mask);
    }
}

方式③ 仅当一个哲学家左右两支筷子都可用时才允许他抓起筷子。

import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 仅当一个哲学家左右两支筷子都可用时才允许他抓起筷子。
 */

class DiningPhilosophers {

    public DiningPhilosophers() {

    }

    //若 chopstick 等于 0, 表示筷子未被使用
    AtomicInteger chopstick = new AtomicInteger();
    // 00001, 00010, 00100, 01000, 10000
    int[] chopstickMask = new int[]{1, 2, 4, 8, 16};

    //进入临界区
    AtomicInteger mutex = new AtomicInteger();


    // call the run() method of any runnable to execute its code
    public void wantsToEat(int philosopher,
                           Runnable pickLeftFork,
                           Runnable pickRightFork,
                           Runnable eat,
                           Runnable putLeftFork,
                           Runnable putRightFork) throws InterruptedException {
        //左右筷子
        int leftC = chopstickMask[philosopher];
        int rightC = chopstickMask[(philosopher + 1) % 5];
        //信号量 -1
        //进入临界区
        while (!mutex.compareAndSet(0, 1)) {
            Thread.sleep(1);
        }
        //尝试拿起左右筷子
        while (!get(leftC)) {
            Thread.sleep(1);
        }
        while (!get(rightC)) {
            Thread.sleep(1);
        }
        //退出临界区
        while (!mutex.compareAndSet(1, 0)) {
            Thread.sleep(1);
        }

        pickLeftFork.run();
        pickRightFork.run();
        //eat
        eat.run();
        putLeftFork.run();
        putRightFork.run();
        //放下左右筷子
        while (!put(leftC)) {
            Thread.sleep(1);
        }
        while (!put(rightC)) {
            Thread.sleep(1);
        }
        //信号量 + 1
    }

    private boolean put(int mask) {
        int expect = chopstick.get();
        //例如：1 号放下筷子 00001 和 00010
        // 左边的筷子 expect : 00011 ^ 00001 -> 00010
        // 右边的筷子 expect : 00010 ^ 00010 -> 00000
        return chopstick.compareAndSet(expect, expect ^ mask);
    }

    //尝试拿起左右筷子
    private boolean get(int mask) {
        int expect = chopstick.get();
        //只有当前筷子没有被拿起才返回 true, 并且更新筷子状态
        // 例如：1 号拿起筷子 00001 和 00010 , 更新后 : 00011 (说明1, 2号筷子被拿了)
        //  此时 2 号想拿起左边的筷子 : 00010 , & 运算发现被拿了, 返回false
        return (expect & mask) <= 0 && chopstick.compareAndSet(expect, expect ^ mask);
    }
}

4、总结

哲学家进餐问题的关键在于解决进程死锁。

这些进程之间只存在互斥关系，但是与之前接触到的互斥关系不同的是，每个进程都需要同时持有两个临界资源，因此就有“死锁”问题的隐患。

如果在考试中遇到了一个进程需要同时持有多个临界资源的情况，应该参考哲学家问题的思想，分析题中给出的进程之间是否会发生循环等待，是否会发生死锁。

可以参考哲学家就餐问题解决死锁的三种思路。

伤如之何?
关注
  • 1
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
哲学家问题
ensemblelearning的博客
06-05 556
哲学家问题 有五个哲学家绕着圆桌坐，每个哲学家面前有一盘面，两人之间有一支筷子，这样每个哲学家左右各有一支筷子。哲学家有2个状态，思考或者拿起筷子吃饭。如果哲学家拿到一只筷子，不能吃饭，直到拿到2只才能吃饭，并且一次只能拿起身边的一支筷子。一旦拿起便不会放下筷子直到把饭吃完，此时才把这双筷子放回原处。如果，很不幸地，每个哲学家拿起他或她左边的筷子，那么就没有人可以吃到饭了。 解决方案1： 控制最多有4位哲学家拿起1根筷子，保证至少有一位哲学家可以吃到饭，并且在吃完后释放筷子，使其他哲学家可以吃饭。 先定义头
哲学家就餐问题
newarraylist的专栏
08-25 1031
哲学家就餐问题在计算机操作系统中是一个很经典的问题，曾经我在我的操作系统课程设计中用C语言做过一个哲学家就餐问题的模拟。当时做得非常的吃力，因为确实在C语言这方面学的东西太少，关于进程的编程都是靠着看那本操作系统的实验册，实验册很薄啊，里面的东西确实是很有限啊，做得很郁闷。当时我和那代码谁也不认识谁，搞了2，3个晚上，好不容易弄出个东西，连进程并发都不会，但由于时间所限，只能草草交差，一直很遗憾啊
哲学家进餐问题——经典进程同步问题
weixin_53236070的博客
03-21 9518
哲学家进餐问题——经典进程同步问题
经典的进程同步问题-----哲学家进餐问题详解
热门推荐
丹丹的后花园
11-25 3万+
​ 本文和接下来几篇博文是对上篇文章（进程同步机制）的一次实践，通过具体的例子来加深理论的理解，会用三个经典的进程同步问题来进行讲解，并且会配有伪代码和Java实践（使用多线程模拟），深入的进行讲解。 ​ 进程同步问题是一个非常重要且相当有趣的问题，本文我们对其中比较有名的哲学家进餐问题来进行探讨。哲学家进餐问题是诸进程间竞争临界资源而导致死锁的典型例子，具有很大的代表性，因此在这里我们也对其进行...
哲学家问题（死锁问题）
weixin_45511599的博客
06-05 4739
1.问题描述 有五个哲学家绕着圆桌坐，每个哲学家面前有一盘面，两人之间有一支筷子，这样每个哲学家左右各有一支筷子。哲学家有2个状态，思考或者拿起筷子吃饭。如果哲学家拿到一只筷子，不能吃饭，直到拿到2只才能吃饭，并且一次只能拿起身边的一支筷子。一旦拿起便不会放下筷子直到把饭吃完，此时才把这双筷子放回原处。如果，很不幸地，每个哲学家拿起他或她左边的筷子，那么就没有人可以吃到饭了。 哲学家进餐问题是一个多线程运用的经典例子，涉及到线程同步/互斥，临界区访问问题以及死锁问题。 ** 2 解题思路 ** ​ 因为是五
哲学家进餐问题
惜朝歌的博客
05-07 9531
哲学家进餐问题
增霸卡V2.20 for Dell
01-10
增霸卡V2.20 for Dell
selenium chromedriver2.20 最新
12-23
web自动化不可或缺的组件，支持Chrome 44+，为最新版本。
Antnest2.20
07-06
Antnest控制器，内含2.02固件。 蚁巢---突破电脑外部存储的封锁，助您把您的心血带回家。详情请搜索X宝
科研论文图片数据提取工具：GetData2.20
09-05
还在为科研论文图片无法得到数据发愁吗？就让“科研论文图片数据提取工具：GetData2.20”来帮你轻松实现论文图片的数据提取，只要有图就有数据！还附上详细的图文教程，是科研工作的必备软件！
哲学家就餐问题源程序
12-21
关于5个哲学家就餐线程同步问题的解决方法 此方法对左右手刀叉实行控制，防止了死锁，实现了线程的同步 注意5个以上的哲学家亦可用此方法解决
信号量同步实验报告（哲学家进餐问题避免死锁的三种方法）
04-15
操作系统初学，关于信号量同步的实验报告，用三种方法避免哲学家进餐问题死锁，a:and信号量，b:控制进餐人数，c设置条件
基于 ucos-ii操作系统解决哲学家就餐问题
11-24
在ucos2操作系统下，解决互锁问题。即公共资源的分配问题。
docker-compose-2.20.2安装包
08-11
docker-compose-2.20.2安装包
哲学家就餐问题（java实现）
cchoop的博客
04-26 1722
史上最全哲学家就餐问题解法
操作系统-哲学家进餐问题
我房间
10-18 492
哲学家进餐问题： 五个哲学家共用一张圆桌，分别坐在周围的五张椅子上，在桌子上有五只碗和五只筷子，他们的生活方式是交替地进行思考和进餐。平时，一个哲学家进行思考，饥饿时便试图取用其左右最靠近他的筷子，只有在他拿到两只筷子时才能进餐。进餐毕，放下筷子继续思考。 分析：放在桌子上的筷子是临界资源，在一段时间内只允许一位哲学家使用，为了实现对筷子的互斥访问，可以用一个信号量表示筷子，由这五个信号量构成信号量数组。 semaphore chopstick[5] = {1,1,1,1,1}; while(tr
五个哲学家就餐问题
low5252的博客
03-11 2万+
哲学家就餐问题 1 描述 哲学家就餐问题是在计算机科学中的一个经典问题，用来演示在并行计算中多线程同步(Synchronization)时产生的问题。在1971年，著名的计算机科学家艾兹格.迪科斯彻提出了一个同步问题，即假设有五台计算机都试图访问五份共享的磁带驱动器。稍后，这个问题被托尼?霍尔重新表述为哲学家就餐问题。这个问题可以用来解释死锁和资源耗尽。 哲学家就餐问题可以这样表述，假设有五位哲学...
1226. 哲学家进餐 （场景 / 破坏死锁条件）
lankerens
11-23 3548
LeetCode： 1226. 哲学家进餐 题目大意： 一共有0,1,2,3,40,1,2,3,40,1,2,3,4 五个哲学家，他们之间都只有思考问题和进餐两个动作。 而进餐时需要同时持有左右两边的叉子才能完成进餐。 需要我们控制线程的的并行访问，使所有的哲学家都达到了 n 次进餐 当每个哲学家都持有自己右边的叉子， 这样就会造成互相阻塞等待，出现死锁。 题目的主要思想就是避免死锁的出现。 小贴士： 回顾避免死锁的四个条件； 循环等待条件 （互相持有资源而等待彼此的释放） 请求与保持条件 不可
【经典操作系统问题】哲学家就餐问题分析
游手好弦 信步涂鸦
05-22 2608
  　1． 哲学家进餐问题：　　(1) 在什么情况下5 个哲学家全部吃不上饭？　　考虑两种实现的方式，如下：　　A.　　算法描述：　　void philosopher(int i) /*i：哲学家编号，从0 到4*/　　{　　while (TRUE) {　　think( ); /*哲学家正在思考*/　　take_f
masterpwv2.20
最新发布
02-02
因此，masterpwv2.20版本可能比先前版本更加安全和功能强大。 对于用户而言，使用masterpwv2.20可以带来很多好处。首先，它可以为用户提供一个方便的平台来存储和管理他们的密码，避免忘记密码的问题。其次，生成强...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值