Java实现生产者消费者的三种方式

最新推荐文章于 2024-04-12 17:04:24 发布
最新推荐文章于 2024-04-12 17:04:24 发布
阅读量775 收藏 3
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yexiguafu/article/details/103535251
版权

一、使用synchronize以及wait()、notify() /notifyAll()

package com.zhb.juc;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 使用synchronize wait notify/notifyall实现生产者消费者模式
 */

class ShareDataV1 {
    public static AtomicInteger atomicInteger = new AtomicInteger();
    public volatile boolean flag = true;
    public static final int MAX_COUNT = 10;
    public static final List<Integer> pool = new ArrayList<>();

    public void produce() {
        // 判断，干活，通知
        while (flag) {
            // 每隔 1000 毫秒生产一个商品
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
            }
            synchronized (pool) {
                //池子满了，生产者停止生产
                //埋个坑，这里用的if
                //TODO 判断
                if (pool.size() == MAX_COUNT) {
                    try {
                        System.out.println("pool is full, wating...");
                        pool.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //干活
                pool.add(atomicInteger.incrementAndGet());
                System.out.println("produce number:" + atomicInteger.get() + "\t" + "current size:" + pool.size());
                //通知
                pool.notifyAll();
            }
        }
    }

    public void consumue() {
        // 判断，干活，通知
        while (flag) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
            synchronized (pool) {
                //池子满了，生产者停止生产
                //埋个坑，这里用的if
                //TODO 判断
                if (pool.size() == 0) {
                    try {
                        System.out.println("pool is empty, wating...");
                        pool.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //干活
                int temp = pool.get(0);
                pool.remove(0);
                System.out.println("cousume number:" + temp + "\t" + "current size:" + pool.size());
                //通知
                pool.notifyAll();
            }
        }
    }

    public void stop() {
        flag = false;
    }
}

public class ProducerConsumer_V1 {

    public static void main(String[] args) {
        ShareDataV1 shareDataV1 = new ShareDataV1();
        new Thread(() -> {
            shareDataV1.produce();
        }, "AAA").start();

        new Thread(() -> {
            shareDataV1.consumue();
        }, "BBB").start();

        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        shareDataV1.stop();
    }
}

上面的程序在只有两个线程时（一个生产者，一个消费者）可以正常工作。打印的log如下：

produce number:1    current size:1
produce number:2    current size:2
produce number:3    current size:3
produce number:4    current size:4
produce number:5    current size:5
produce number:6    current size:6
produce number:7    current size:7
produce number:8    current size:8
produce number:9    current size:9
cousume number:1    current size:8
produce number:10    current size:9
produce number:11    current size:10
pool is full, wating...
cousume number:2    current size:9
produce number:12    current size:10
pool is full, wating...
cousume number:3    current size:9
produce number:13    current size:10
pool is full, wating...
cousume number:4    current size:9
produce number:14    current size:10
pool is full, wating...
cousume number:5    current size:9
produce number:15    current size:10

Process finished with exit code 0

但是我们把生产者和消费者线程扩展至多个。就出错了。例如再增加CCC和DDD线程分别生产和消费。只改动了main方法：

public class ProducerConsumer_V1 {

    public static void main(String[] args) {
        ShareDataV1 shareDataV1 = new ShareDataV1();
        new Thread(() -> {
            shareDataV1.produce();
        }, "AAA").start();

        new Thread(() -> {
            shareDataV1.consumue();
        }, "BBB").start();

        new Thread(() -> {
            shareDataV1.produce();
        }, "CCC").start();

        new Thread(() -> {
            shareDataV1.consumue();
        }, "DDD").start();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        shareDataV1.stop();
    }
}

输出的log如下：

produce number:1    current size:1
produce number:2    current size:2
produce number:3    current size:3
produce number:4    current size:4
produce number:5    current size:5
produce number:6    current size:6
produce number:7    current size:7
produce number:8    current size:8
produce number:9    current size:9
produce number:10    current size:10
pool is full, wating...
pool is full, wating...
cousume number:1    current size:9
cousume number:2    current size:8
produce number:11    current size:9
produce number:12    current size:10
pool is full, wating...
pool is full, wating...
cousume number:3    current size:9
produce number:13    current size:10
produce number:14    current size:11
cousume number:4    current size:10
pool is full, wating...
pool is full, wating...
cousume number:5    current size:9
produce number:15    current size:10
produce number:16    current size:11
cousume number:6    current size:10
pool is full, wating...
pool is full, wating...
cousume number:7    current size:9
produce number:17    current size:10
produce number:18    current size:11
cousume number:8    current size:10
pool is full, wating...
pool is full, wating...
cousume number:9    current size:9
produce number:19    current size:10
produce number:20    current size:11
cousume number:10    current size:10
pool is full, wating...
pool is full, wating...
cousume number:11    current size:9
produce number:21    current size:10
produce number:22    current size:11

Process finished with exit code 0

我们看到current size 能到11了。这肯定出错了。因为我们要求pool的最大容量为10。出现这个情况的原因是在多线程的环境下，要防止虚假唤醒。即判断条件不能用if，而是用while。接下来我们修改上面//TODO部分的代码，把if改成while再来测试。最终版正确的代码如下：

package com.zhb.juc;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 使用synchronize wait notify/notifyall实现生产者消费者模式
 */

class ShareDataV1 {
    public static AtomicInteger atomicInteger = new AtomicInteger();
    public volatile boolean flag = true;
    public static final int MAX_COUNT = 10;
    public static final List<Integer> pool = new ArrayList<>();

    public void produce() {
        // 判断，干活，通知
        while (flag) {
            // 每隔 1000 毫秒生产一个商品
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
            }
            synchronized (pool) {
                //池子满了，生产者停止生产
                //埋个坑，这里用的if
                //TODO 判断
                while (pool.size() == MAX_COUNT) {
                    try {
                        System.out.println("pool is full, wating...");
                        pool.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //干活
                pool.add(atomicInteger.incrementAndGet());
                System.out.println("produce number:" + atomicInteger.get() + "\t" + "current size:" + pool.size());
                //通知
                pool.notifyAll();
            }
        }
    }

    public void consumue() {
        // 判断，干活，通知
        while (flag) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
            synchronized (pool) {
                //池子满了，生产者停止生产
                //埋个坑，这里用的if
                //TODO 判断
                while (pool.size() == 0) {
                    try {
                        System.out.println("pool is empty, wating...");
                        pool.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //干活
                int temp = pool.get(0);
                pool.remove(0);
                System.out.println("cousume number:" + temp + "\t" + "current size:" + pool.size());
                //通知
                pool.notifyAll();
            }
        }
    }

    public void stop() {
        flag = false;
    }
}

public class ProducerConsumer_V1 {

    public static void main(String[] args) {
        ShareDataV1 shareDataV1 = new ShareDataV1();
        new Thread(() -> {
            shareDataV1.produce();
        }, "AAA").start();

        new Thread(() -> {
            shareDataV1.consumue();
        }, "BBB").start();

        new Thread(() -> {
            shareDataV1.produce();
        }, "CCC").start();

        new Thread(() -> {
            shareDataV1.consumue();
        }, "DDD").start();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        shareDataV1.stop();
    }
}

输出结果：

produce number:1    current size:1
produce number:2    current size:2
produce number:3    current size:3
produce number:4    current size:4
produce number:5    current size:5
produce number:6    current size:6
produce number:7    current size:7
produce number:8    current size:8
produce number:9    current size:9
produce number:10    current size:10
pool is full, wating...
pool is full, wating...
cousume number:1    current size:9
produce number:11    current size:10
pool is full, wating...
cousume number:2    current size:9
produce number:12    current size:10
pool is full, wating...
pool is full, wating...
cousume number:3    current size:9
produce number:13    current size:10
pool is full, wating...
cousume number:4    current size:9
produce number:14    current size:10
pool is full, wating...
pool is full, wating...
cousume number:5    current size:9
produce number:15    current size:10
pool is full, wating...
cousume number:6    current size:9
produce number:16    current size:10
pool is full, wating...
pool is full, wating...
cousume number:7    current size:9
produce number:17    current size:10
pool is full, wating...
cousume number:8    current size:9
produce number:18    current size:10
pool is full, wating...
pool is full, wating...
cousume number:9    current size:9
produce number:19    current size:10
pool is full, wating...
cousume number:10    current size:9
produce number:20    current size:10
cousume number:11    current size:9

Process finished with exit code 0

二、使用Lock，Condition的await和signal方法

JUC包下的锁Lock替代synchronize关键字。await方法代替wait，signal代替notifyall。
下面这个demo实现了pool的大小为1的生产者消费者模型。

package com.zhb.juc;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class ShareData {
    private int number = 0;
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    public void increment() throws Exception {
        lock.lock();
        try { 
            while (number != 0) {
                //等待，不能生产
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName() + "\t" + number);

            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }


    }

    public void decrement() throws Exception {
        lock.lock();
        try {
            while (number == 0) {
                //等待，不能消费
                condition.await();
            }

            number--;
            System.out.println(Thread.currentThread().getName() + "\t" + number);

            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }


    }
}

public class ProducerConsumer_V2{
    public static void main(String[] args) {
        ShareData shareData = new ShareData();

        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    shareData.increment();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }, "AA").start();

        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    shareData.decrement();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }, "BB").start();

        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    shareData.increment();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }, "CC").start();

        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    shareData.decrement();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }, "DD").start();
    }
}

三、终极版使用阻塞队列

首先谈谈阻塞队列：
当阻塞队列为空时，从阻塞队列中取数据的操作会被阻塞。
当阻塞队列为满时，往阻塞队列中添加数据的操作会被阻塞。

ArrayBlockingQueue:
基于数组的阻塞队列实现，其内部维护一个定长的数组，用于存储队列元素。线程阻塞的实现是通过ReentrantLock来完成的，数据的插入与取出共用同一个锁，因此ArrayBlockingQueue并不能实现生产、消费同时进行。而且在创建ArrayBlockingQueue时，我们还可以控制对象的内部锁是否采用公平锁，默认采用非公平锁。

LinkedBlockingQueue:

基于单向链表的阻塞队列实现，在初始化LinkedBlockingQueue的时候可以指定对立的大小，也可以不指定，默认类似一个无限大小的容量（Integer.MAX_VALUE），不指队列容量大小也是会有风险的，一旦数据生产速度大于消费速度，系统内存将有可能被消耗殆尽，因此要谨慎操作。另外LinkedBlockingQueue中用于阻塞生产者、消费者的锁是两个（锁分离），因此生产与消费是可以同时进行的。

参考：https://www.jianshu.com/p/f4eefb069e27

下面是使用阻塞队列实现生产者消费者模式：

package com.zhb.juc;

/*
使用阻塞队列实现生产者消费者模型
 */

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;


//资源类
class ShareDataV3{
    private static final int MAX_CAPACITY = 10; //阻塞队列容量
    private static BlockingQueue<Integer> blockingQueue= new ArrayBlockingQueue<>(MAX_CAPACITY); //阻塞队列
    private  volatile boolean FLAG = true;
    private  AtomicInteger atomicInteger = new AtomicInteger();

    public void produce() throws InterruptedException {
        while (FLAG){
            boolean retvalue = blockingQueue.offer(atomicInteger.incrementAndGet(), 2, TimeUnit.SECONDS);
            if (retvalue==true){
                System.out.println(Thread.currentThread().getName()+"\t 插入队列"+ atomicInteger.get()+"成功"+"资源队列大小= " + blockingQueue.size());
            }else {
                System.out.println(Thread.currentThread().getName()+"\t 插入队列"+ atomicInteger.get()+"失败"+"资源队列大小= " + blockingQueue.size());

            }
          TimeUnit.SECONDS.sleep(1);
        }
        System.out.println(Thread.currentThread().getName()+"FLAG变为flase，生产停止");
    }

    public void consume() throws InterruptedException {
        Integer result = null;
        while (true){
            result = blockingQueue.poll(2, TimeUnit.SECONDS);
            if (null==result){
                System.out.println("超过两秒没有取道数据，消费者即将退出");
                return;
            }
            System.out.println(Thread.currentThread().getName()+"\t 消费"+ result+"成功"+"\t\t"+"资源队列大小= " + blockingQueue.size());
            Thread.sleep(1500);
        }

    }

    public void stop() {
        this.FLAG = false;
    }
}

public class ProducerConsumer_V3 {

    public static void main(String[] args) {
        ShareDataV3 v3 = new ShareDataV3();
        new Thread(()->{
            try {
                v3.produce();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "AAA").start();

        new Thread(()->{
            try {
                v3.consume();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "BBB").start();

        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        v3.stop();
    }
}

可以看到使用阻塞队列根本不需要我们去加锁，通知什么的，完全解放了。

运行结果：

AAA     插入队列1成功资源队列大小= 0
BBB     消费1成功      资源队列大小= 0
AAA     插入队列2成功资源队列大小= 1
BBB     消费2成功      资源队列大小= 0
AAA     插入队列3成功资源队列大小= 1
BBB     消费3成功      资源队列大小= 1
AAA     插入队列4成功资源队列大小= 1
AAA     插入队列5成功资源队列大小= 2
BBB     消费4成功      资源队列大小= 1
AAA     插入队列6成功资源队列大小= 2
AAAFLAG变为flase，生产停止
BBB     消费5成功      资源队列大小= 1
BBB     消费6成功      资源队列大小= 0
超过两秒没有取道数据，消费者即将退出

Process finished with exit code 0
叹了口丶气
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Java实现生产者和消费者模式
2401_83641360的博客
04-17 661
这博客是对自己学习的一点点总结及记录，如果您对Java算法感兴趣，可以关注我的动态，我们一起学习。
Java 生产者和消费者3种实现方式
小博要变强啊~
01-24 743
Java 生产者和消费者3种实现方式。
三种方式实现Java生产者与消费者
木子陈的博客
03-10 6556
一、什么是生产者与消费者 生产者与消费者是java并发环境下常见的设计模式，一个线程负责生产数据，一个线程负责消费数据，两个线程同时去操作这个变量，但是这是两个相互互斥的操作。 二、代码演示 1、使用synchronized来实现，必须结合wait()与notify()方法来互斥，代码如下： /** * synchronized 版本生产者与消费者 */ public class SynchronizedConsumerAndProducer { /** * 队列长度
Java实现生产者消费者模型的三种方式
gbj2020的博客
12-11 1549
生产者-消费者模型是一种多线程并发模型，其中生产者线程负责生产数据，并将数据放入共享的缓冲区中，而消费者线程则负责从缓冲区中取出数据并进行处理。
一文理解java多线程之生产者消费者模型（三种实现）
最新发布
qq_43800449的博客
04-12 2225
生产者和消费者之间通过一个缓冲区来进行交互，生产者负责生成数据，然后存入缓冲区；消费者则负责消费数据，从缓冲区获取。生产者和消费者只和缓冲区交互，没有直接联系。其中的同步互斥关系：生产者之间互斥，消费者之间也互斥生产者与消费者之间既又同步也有互斥（缓冲区满时，只能消费完再生产；缓冲区空时，只能生产完再消费）注意：缓存区要先进先出，所以一般用队列实现为什么要用生产者-消费者模型？
Java 生产者-消费者模式的 3 种实现
weixin_41750142的博客
03-18 594
Java 生产者-消费者模式的 3 种实现
Java实现简易生产者消费者模型过程解析
08-19
二、Java实现生产者消费者模型 在Java中，生产者消费者模型可以通过使用同步机制和wait/notify机制来实现。在下面的示例代码中，我们将创建四个类：生产者类、产品类、消费者类和测试类。 生产者类 生产者类负责...
Java多种方式实现生产者消费者模式
08-18
Java中实现生产者消费者模式有多种方式，下面将详细介绍两种方式：使用synchronized和Object的wait和notifyAll方法，使用jdk1.8的Lock和Condition。 方式一：使用synchronized和Object的wait和notifyAll方法 在...
java实现生产者消费者
10-18
在Java中，`java.util.concurrent`包下的`BlockingQueue`接口提供了一种线程安全的数据结构，非常适合用于实现生产者消费者模式。生产者将产品放入队列，消费者从队列中取出产品。`BlockingQueue`提供了`put()`和`...
java生产者消费者问题代码实现
12-25
在本文中，我们将使用 Java 语言来实现生产者消费者问题的解决方案。我们将使用多线程编程技术来模拟生产者和消费者之间的关系，并使用 synchronized 关键字来实现线程同步。 首先，我们需要定义一个缓冲区来存放...
Java实现Kafka生产者消费者代码实例
08-19
主要介绍了Java实现Kafka生产者消费者代码实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java设计模式之生产者/消费者模式
红日
01-19 4302
一、什么是生产者/消费者模式？ 某个模块负责产生数据，这些数据由另一个模块来负责处理（此处的模块是广义的，可以是类、函数、线程、进程等）。产生数据的模块，就形象地称为生产者；而处理数据的模块，就称为消费者。在生产者与消费者之间在加个缓冲区，我们形象的称之为仓库，生产者负责往仓库了进商品，而消费者负责从仓库里拿商品，这就构成了生产者消费者模式。结构图如下： 二、生产者消费者模式的优点： 1、解耦: 由于有缓冲区的存在，生产者和消费者之间不直接依赖，耦合度降低。 2、支持并发: 由于生产者与消费者是两个独立的
11-JUC中的Condition对象
永无止境
04-28 598
文章目录ConditionCondition常用方法总结参考 Condition 任何一个java对象都天然继承于Object类，在线程间实现通信的往往会应用到Object的几个方法，比如wait()、wait(long timeout)、wait(long timeout, int nanos)与notify()、notifyAll()几个方法实现等待/通知机制，同样的， 在java Lock体...
JDK8版本后生产者与消费者问题的代码实现
weixin_48149536的博客
05-31 302
package com.dym.jvm; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; class ShareData//资源类 { private int number = 0;//初始值为零的一个变量 private Lock lock = ...
基于java的生产者和消费者三种实现方式
qq_16622819的博客
04-12 3924
1、概述    生产者和消费者问题是一个经典的线程同步问题。生产者（Producer）生产产品（Product），放入仓库（Repertory）；消费者（Consumer）消费产品，从仓库里获取。仓库爆满时生产者等待消费者消费，仓库为空时消费者等待生产者生产。2、实现2.1、synchronized    生产者Producer：        public class Producer impl...
java实现生产者和消费者
热门推荐
fallwind_of_july的博客
06-19 1万+
本篇博文主要介绍如何使用java来实现简单的生产者和消费者 来帮助大家简单的入门理解生产者和消费者模式 一、对生产者消费者的理解 生产者消费者模式是并发、多线程编程中经典的设计模式。 简单来看，就是一个类负责生产，一个类负责消费。举例来说，一个变量，生产者不断增加这个变量，消费者不断减少这个变量。在互联网应用中，抢票机制就是应用了该模式，比如大麦网演唱会门票抢票，12306火车票抢票等。
Java生产者、消费者模式的几种实现方式
小马快跑的博客
07-21 1198
文章目录方式一：BlockingQueue方式(最优方式)方式二：Synchronized+wait/notifyAll方式方式三：ReentrantLock+Condition方式几种方式对比参考 方式一：BlockingQueue方式(最优方式) private static final String THREAD_PRODUCE = "生产者"; private static final String THREAD_CONSUME = "消费者"; //阻塞队列中最多存5个 private stati
JDK1.8并发之生产者消费者问题
哈罗德Android笔记
06-24 1051
本文讨论了生产者消费者模式的三种实现方式，第三种BlockingQueue实际上就是JDK对第二种方式的封装。为了提高程序的拓展性，方便测试，我用StockRoom接口来抽象产品库存的put和take操作。这样三种实现方式可以使用相同的Producer和Consumer类代码。这些可复用的代码如下： // 测试方法： private static void test(StockRoom st...
阻塞队列实现生产者消费者模式
blog
11-05 1904
生产者消费者模式是并发、多线程编程中经典的设计模式，生产者和消费者通过分离的执行工作解耦，简化了开发模式，生产者和消费者可以以不同的速度生产和消费数据。这篇文章我们来看看什么是生产者消费者模式，这个问题也是多线程面试题中经常被提及的。如何使用阻塞队列（Blocking Queue）解决生产者消费者模式，以及使用生产者消费者模式的好处。 真实世界中的生产者消费者模式 生产者和消费者模
java项目代码java项目代码.doc
06-11
此代码片段中，作者使用了Java的多线程机制来实现生产者和消费者的并发操作，可能涉及了`wait()`、`notify()`或`notifyAll()`等方法来协调线程间的同步，但具体实现并未在提供的代码片段中展示。实际的项目可能还...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

叹了口丶气

觉得有收获就支持一下吧~

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值