使用Object对象的wait和notify来实现一个生产者消费者模型

最新推荐文章于 2022-03-24 15:05:34 发布
最新推荐文章于 2022-03-24 15:05:34 发布
阅读量422 收藏 2
点赞数
分类专栏： java 文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Myc_CSDN/article/details/103847113
版权

今天学习Object的wait和notify。使用这两个方法实现一个生产者、消费者模型

首先定义一个仓库类，因为生产者还是消费者，都要从仓库存或者取

public class Storage {
    // 仓库的最大容量
    private int maxSize;
    // 具体的仓库
    private LinkedList<Date> storage;

    public Storage() {
        this.maxSize = 10;
        this.storage = new LinkedList<>();
    }

    /**
     * 往仓库放产品
     * synchronized 放在方法上，那么该方法获取的就是当前对象的锁
     */
    public synchronized void put() {
        // 检测仓库是否满了，如果满了，就通知消费者取东西（释放锁）
        while(this.storage.size() == maxSize) {
            // 释放当前对象的锁
            try {
                wait();
            } catch(InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.storage.add(new Date());
        System.out.println("仓库中有了" + storage.size() + "个产品");
        // 仓库中有了产品，就唤醒其他线程，来消费产品，本例中只有两个线程，
        // 一个生产者、一个消费者，故，此处唤醒的就是消费者了
        notify();
    }

    /**
     * 消费仓库中的产品
     */
    public synchronized void take() {
        // 检测仓库中是否有产品，有就消费，没有就等待
        while(this.storage.size() == 0) {
            try {
                // 由于仓库中没有东西，所以，就把锁释放了，让生产者获得锁，去生产
                wait();
            } catch(InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("消费者消费了：" + this.storage.poll() + ",目前还剩下：" + this.storage.size()+ "个产品");
        // 消费者消费了产品，就通知生产者继续生产
        notify();
    }
}

定义生产者类

/**
 * 生产者类
 */
public class Producer implements Runnable {
	// 需要仓库去放产品
	private Storage storage;
	public Producer(Storage storage) {
		this.storage = storage;
	}
	@Override
	public void run() {
		// 生产100个产品
		for (int i = 0; i < 100; i++) {
            storage.put();
        }
	}
}

定义消费者类

/**
 * 消费者
 */
public class Consumer implements Runnable {
	private Storage storage;
	public Consumer(Storage storage) {
		this.storage = storage;
	}

	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
            storage.take();
        }
	}
}

主函数

public class ProducerConsumerModerByWaitAndNotify {
	public static void main(String[] args) {
		Storage storage = new Storage();
        Thread producer = new Thread(new Producer(storage));
        Thread consumer = new Thread(new Consumer(storage));
        producer.start();
        consumer.start();
	}
}

运行结果如下

仓库中有了1个产品
仓库中有了2个产品
仓库中有了3个产品
仓库中有了4个产品
仓库中有了5个产品
仓库中有了6个产品
仓库中有了7个产品
仓库中有了8个产品
仓库中有了9个产品
仓库中有了10个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：9个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：8个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：7个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：6个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：5个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：4个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：3个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：2个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：1个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：0个产品
仓库中有了1个产品
仓库中有了2个产品
仓库中有了3个产品
仓库中有了4个产品
仓库中有了5个产品
仓库中有了6个产品
仓库中有了7个产品
仓库中有了8个产品
仓库中有了9个产品
仓库中有了10个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：9个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：8个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：7个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：6个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：5个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：4个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：3个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：2个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：1个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：0个产品
仓库中有了1个产品
仓库中有了2个产品
仓库中有了3个产品
仓库中有了4个产品
仓库中有了5个产品
仓库中有了6个产品
仓库中有了7个产品
仓库中有了8个产品
仓库中有了9个产品
仓库中有了10个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：9个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：8个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：7个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：6个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：5个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：4个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：3个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：2个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：1个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：0个产品
仓库中有了1个产品
仓库中有了2个产品
仓库中有了3个产品
仓库中有了4个产品
仓库中有了5个产品
仓库中有了6个产品
仓库中有了7个产品
仓库中有了8个产品
仓库中有了9个产品
仓库中有了10个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：9个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：8个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：7个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：6个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：5个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：4个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：3个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：2个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：1个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：0个产品
仓库中有了1个产品
仓库中有了2个产品
仓库中有了3个产品
仓库中有了4个产品
仓库中有了5个产品
仓库中有了6个产品
仓库中有了7个产品
仓库中有了8个产品
仓库中有了9个产品
仓库中有了10个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：9个产品
仓库中有了10个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：9个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：8个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：7个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：6个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：5个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：4个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：3个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：2个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：1个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：0个产品
仓库中有了1个产品
仓库中有了2个产品
仓库中有了3个产品
仓库中有了4个产品
仓库中有了5个产品
仓库中有了6个产品
仓库中有了7个产品
仓库中有了8个产品
仓库中有了9个产品
仓库中有了10个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：9个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：8个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：7个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：6个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：5个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：4个产品
仓库中有了5个产品
仓库中有了6个产品
仓库中有了7个产品
仓库中有了8个产品
仓库中有了9个产品
仓库中有了10个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：9个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：8个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：7个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：6个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：5个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：4个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：3个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：2个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：1个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：0个产品
仓库中有了1个产品
仓库中有了2个产品
仓库中有了3个产品
仓库中有了4个产品
仓库中有了5个产品
仓库中有了6个产品
仓库中有了7个产品
仓库中有了8个产品
仓库中有了9个产品
仓库中有了10个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：9个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：8个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：7个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：6个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：5个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：4个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：3个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：2个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：1个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：0个产品
仓库中有了1个产品
仓库中有了2个产品
仓库中有了3个产品
仓库中有了4个产品
仓库中有了5个产品
仓库中有了6个产品
仓库中有了7个产品
仓库中有了8个产品
仓库中有了9个产品
仓库中有了10个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：9个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：8个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：7个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：6个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：5个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：4个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：3个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：2个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：1个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：0个产品
仓库中有了1个产品
仓库中有了2个产品
仓库中有了3个产品
仓库中有了4个产品
仓库中有了5个产品
仓库中有了6个产品
仓库中有了7个产品
仓库中有了8个产品
仓库中有了9个产品
仓库中有了10个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：9个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：8个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：7个产品
仓库中有了8个产品
仓库中有了9个产品
仓库中有了10个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：9个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：8个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：7个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：6个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：5个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：4个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：3个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：2个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：1个产品
消费者消费了：Sun Jan 05 21:10:15 CST 2020,目前还剩下：0个产品

Process finished with exit code 0

总结

wait和nofity只能用在synchronized关键字包围的代码块中，synchronized能够获取一个对象的锁，而当我们调用了wait()方法后，正在执行到wait方法的线程就会等待，也就是释放了已经获取到的monitor锁，一直等到其他线程使用nofity()或者notifyAll()方法来唤醒他，那么他就会再次阻塞状态，等待CPU调度，获取到锁。

和Java狼狈为奸
关注
专栏目录
java多线程系列——（2）wait和notify方法实现生产者消费者问题
BodyCoding
07-13 392
1. 概要 Object类中提供有wait()、notify()、notifyAll()方法来使线程等待和唤醒。那么问题来了，为什么对线程的等待和唤醒要定义在object类中呢？ 因为wait(),notify(),notifyAll()都必须使用在同步中，因为要对持有监视器(锁)的线程操作。所以要使用在同步中，因为只有同步 才具有锁。wait()会使“当前线程”等待，因为线程进入等待状态，所以线...
生产者消费者模型(wait/notify/notifyAll)
sophia__yu的博客
11-20 539
生产者和消费者之间的阻塞队列 生产者消费者模型在实际生活中很多运用。对我们自己来说就是一个消费者，比如我们需要买奥利奥饼干，我们会去超时买，并不是直接从厂商那里买，而厂商把奥利奥生产结束后会送往各个超市进行售卖，超市就是我们消费者和生产者之间媒介。这个超市在操作系统定义为阻塞队列。 生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞...
使用Java的Object.wait()和Object.notify()实现生产者-消费者问题
qq_20460289的博客
04-12 246
生产者消费问题介绍 定义 一群生产者向一群消费者提供产品，生产者与消费者共享缓存区，其中生产者生产产品，消费者消费产品。 规则 当缓冲区满时，不允许生产者向缓冲区中存产品。 当缓冲区空时，不允许消费者从缓存区中取产品。 每个时刻仅允许1个生产者或消费者存取数据。 操作系统的信号量解决生产者-消费者问题 int empty = n; //信号量：缓冲区中的空位的个数 int full...
使用Object类中的wait()和notify()方法实现生产者和消费者模式
zhengyangzkr的博客
04-19 1025
生产者消费者模式，在实际的开发过程中经常会遇到，平常我们接触到的例如ActiveMQ就是一个一个典型的生产者消费者模式。为了更好的理解生产者和消费这模式，下面通过自己定义的一个消息类、结合Object对象中的wait()和notify()方法实现一个简单的生产者消费者模式。   首先定义一个消息类Info. package com.test.consumer; /** * @生产消息类
wait和notify实现生产者消费者模型
YOUWENWU的专栏
05-12 393
[size=medium]读这篇文章之前，首先要弄明白java对象的两个方法，wait和notify或者notifyAll,那弄懂这两个方法又要知道一个概念，java中Object类有个对象锁，所有的对象都继承自Object类，因此每个对象都有个锁，而且java中的对象锁在同一时刻只能由一个线程持有，这是java在多线程编程中实现互斥的基础。 那一个线程如何获得一个对象的锁呢？根据J...
Java多线程之~~~~使用wait和notify实现生产者消费者模型
Less Is More
11-07 449
在多线程开发中，最经典的一个模型就是生产者消费者模型，他们有一个缓冲区，缓冲区有最大限制，当缓冲区满的时候，生产者是不能将产品放入到缓冲区里面的，当然，当缓冲区是空的时候，消费者也不能从中拿出来产品，这就涉及到了在多线程中的条件判断，Java为了实现这些功能，提供了wait和notify方法，他们可以在线程不满足要求的时候让线程让出来资源等待，当有资源的时候再notify他们让他们继续工作，下面我...
java代码-wait-notify 生产者消费者
07-16
6. **哲学家就餐问题**：这是一个经典的多线程问题，可以使用生产者消费者模型来解决。每个哲学家既是生产者（思考问题），也是消费者（吃饭），通过共享筷子（资源）来实现同步。 7. **Java并发工具类**：除了`...
Object类wait及notify方法原理实例解析
08-24
生产者和消费者模式可以使用wait和notify方法来实现。 实现生产者和消费者模式时，需要使用synchronized关键字来确保线程安全。在生产者线程中，使用wait方法来等待仓库容量达到一定数量后再继续生产。在消费者线程...
写一个生产者消费者模型：思路 wait() 和 notify() 方法来实现
最新发布
09-24
生产者消费者模型是一种经典的并发控制机制，它用于解决两个线程之间的同步问题，一个线程作为生产者负责生产数据，另一个线程作为消费者负责消费数据。在这种模型中，通常会使用Java的`synchronized`, `wait()`, 和...
Java 中Object的wait() notify() notifyAll()方法使用
08-30
在Java并发编程中，Object的wait()、notify()和notifyAll()方法是非常重要的概念，这三个方法都是Object类的方法，可以认为任意一个Object都是一种资源（或者资源的一个代表）。在并发编程中，线程安全是非常重要的...
使用wait和notifyAll实现生产者消费者模型
wang704987562的博客
05-07 373
wait和notifyAll是JDK中Object类的两个方法，主要用来线程间通讯，最经典的应用场景就是【生产者-消费者】，下面给出简单示例。/** * @Auothor wzx * @Date 2017/5/7 0007 */ public class ProducerConsumer { public static void main(String[] args) {
Object的wait和notify实现生产者和消费者
hanliuxi4265的博客
01-28 217
Object的wait和notify实现生产者和消费者 public class ConsumerAndProducer { private int queueSize = 10; private PriorityQueue&lt;Integer&gt; queue = new PriorityQueue&lt;&gt;(queueSize); public stati...
利用object.wait()和实现生产者和消费者模式
雨中漫步--专栏
10-18 230
  其实生产者和消费者模式概念很简单，就是生产者将生产出来的产品放在仓库里，然后消费者依次从仓库里取产品消费。归到程序里，这里的仓库就可以用数组，队列或栈来表示。 掌握以下两点后，该模式的实现将不成问题。 1. 首先要明白生产者和消费者之间的并发对象就是存放产品的队列，这样才能把并发方法提炼出来。 2. 其次要掌握object.wait()和object.notifyAll()...
生产者消费者模式：使用Object.wait() / notify()方法实现
一个搬砖工人
03-24 432
它描述是有一块缓冲区（队列实现）作为仓库，生产者可以将产品放入仓库，消费者则可以从仓库中取走产品。在Java中这个多线程线程同步阻塞的问题，多个用户同时发送多个请求，怎么保证不发生线程死锁，是我们要考虑的问题。 生产者消费者模式说明： 1.生产者只在仓库未满时进行生产，仓库满时生产者进程被阻塞； 2.消费者只在仓库非空时进行消费，仓库为空时消费者进程被阻塞； 3.当消费者发现仓库为空时会通知生产者生产； 3.当生产者发现仓库满时会通知消费者消费； 生产者消费者问题就是要保证不会出现没有商品但是消费者还是一直
关于Object类中的wait()和notify()方法实现生产者和消费者模式
pipizhen_的博客
07-25 272
package thread; /* 关于Object类中的wait()和notify()方法（生产者和消费者模式）： 1、首先，wait()和notify()方法不是线程对象的方法，是java中任何一个对象都有的方法， 因为这两个方法是Object类中自带的。 2、这两个方法的作用： （1）wait()方法的作用： Object obj = new Object(); obj.wait(); 表示：让正在obj对象上活动的当前线程进入等待状态，永久
java多线程之生产者-消费者使用Object的wait()和notify()方法实现
javaZhong的博客
06-02 260
package com.zhong.thread; import java.util.ArrayList; import java.util.List; /** * 使用 wait，notify 实现生产消费者 */ public class Stock { private volatile int maxnum = 10; //最大的容量通知消费者 private volatile int minmun = 0; //最小的容量通知生产者 private St.
关于Object类中的wait和notify方法。（生产者和消费者模式！）
qq_45148387的博客
03-13 211
第一： wait和notify方法不是线程对象的方法，是JAVA众人和一个java对象都有的方法，因为这两个方式是Object类中自带的。 wait方法和notify方法不是通过线程对象调用。 第二： Object o = new Object（）； o.wait（）； 表示： 让正在o对象上活动的线程进入等待状态，无限期等待，直到被唤醒为止。 o.wait（）；方法的调用，会让“当前线程（正在o对象上活动的线程）”进入等待状态。 o.notify（）； 这个方法的调用可以让正在o对象上等待的线程被唤醒。
《wait/notify实现生产者和消费者程序》
weixin_44769619的博客
03-26 231
wait/notify实现生产者和消费者程序 1. 使用注意事项 只能在同步方法或同步块中调用 wait()方法、notify()系列方法 尽可能用 notifyall()，谨慎使用 notify() 2. 示例 2.1 生产者 private Integer zd = 0; // 定义子弹变量 // 生产者生产子弹 public synchronized void set(){...
使用wait notify实现生产者消费者模型
weixin_41029286的博客
07-28 217
一个内存队列，多个生产者线程往内存队列中放数据;多个消费者线程从内存队列中取数据 使用wait()与notify()机制 队列的实现 public class MyQueue { /** * 数组队列（总长度为10） */ private String[] data = new String[10]; /** * 出队列的下标 */ private int getIndex = 0; /** * 入队列的下标
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值