并发编程实现生产者和消费者模式

最新推荐文章于 2024-07-10 09:44:18 发布
最新推荐文章于 2024-07-10 09:44:18 发布
阅读量878 收藏 1
点赞数 1
分类专栏： Java并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/riemann_/article/details/96516365
版权

一、简介

生产者和消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此并不直接通信，而是通过阻塞队列进行通信，所以生产者生产完数据后不用等待消费者进行处理，而是直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列中获取数据，阻塞队列就相当于一个缓冲区，平衡生产者和消费者的处理能力。

二、实现方式

1、synchronized、wait和notify

生产者和消费者线程各一条：

代码实现：

package com.thread.producerAndConsumer;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

/**
 * @author riemann
 * @date 2019/07/20 0:13
 */
public class ProducerAndConsumer {

    public static void main(String[] args) {
        List list = new ArrayList();
        new Thread((new Producer(list)),"生产者线程produce: ").start();
        new Thread((new Consumer(list)),"消费者线程consume: ").start();
    }

}

/**
 * 生产者线程
 */
class Producer implements Runnable {

    private List list;

    public Producer(List list) {
        this.list = list;
    }

    @Override
    public void run() {
        while (true) {
            Random random = new Random();
            synchronized (list) {
                //可以是while
                if (list.size() > 0) {//表明集合中有元素，此线程等待
                    try {
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                list.add(random.nextInt(100));//0-99的随机数
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " " + list.get(0));
                list.notify();//通知消费者，集合中已有元素。
            }
        }
    }

}

/**
 * 消费者线程
 */
class Consumer implements Runnable {

    private List list;

    public Consumer(List list) {
        this.list = list;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (list) {
                //可以是while
                if (list.size() < 1) {
                    try {
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " " + list.remove(0));
                list.notify();
            }
        }
    }
    
}

输出结果：

生产者线程produce:  40
消费者线程consume:  40
生产者线程produce:  9
消费者线程consume:  9
生产者线程produce:  95
消费者线程consume:  95
生产者线程produce:  50
消费者线程consume:  50
生产者线程produce:  33
消费者线程consume:  33
生产者线程produce:  16
消费者线程consume:  16
生产者线程produce:  65
消费者线程consume:  65
生产者线程produce:  87
消费者线程consume:  87
生产者线程produce:  37
消费者线程consume:  37
生产者线程produce:  34
消费者线程consume:  34
生产者线程produce:  33
消费者线程consume:  33

多条生产者和消费者线程：

多条线程需要注意是：

  • 我们唤醒的时候需要使用notifyAll()，如果使用notify（）随机唤醒的可能是同一类线程，这样会导致死锁；
  • 需要将if改为while，比如生产者线程有多个，当本生产者线程wait之后，假如另一个生产者线程得到锁（本该消费者得到），如果是if，那么此线程就会继续执行，会导致数据错乱。如果是while则会继续等待。

代码实现：

package com.thread.producerAndConsumer;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

/**
 * @author riemann
 * @date 2019/07/20 0:52
 */
public class ProducerAndConsumer2 {

    public static void main(String[] args) {
        List list = new ArrayList();
        for (int i = 0; i < 4; i++) {
            new Thread((new Producer(list)),"生产者线程" + i +" - produce: ").start();
            new Thread((new Consumer(list)),"消费者线程" + i +" - consume: ").start();
        }
    }

}

/**
 * 生产者线程
 */
class Producer implements Runnable {

    private List list;

    public Producer(List list) {
        this.list = list;
    }

    @Override
    public void run() {
        while (true) {
            Random random = new Random();
            synchronized (list) {
                while (list.size() > 0) {
                    //因为生产者线程有多个，当本线程wait之后，假如一个生产者线程得到锁（本该消费者得到），
                    // 如果是if，那么此线程就会继续执行，会导致数据错乱。
                    //如果是while则会继续等待。
                    try {
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                list.add(random.nextInt(100));//0-99的随机数
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " " + list.get(0));
                list.notifyAll();//唤醒此对象锁所有等待线程（消费者和生产者线程均有）
            }
        }
    }

}

/**
 * 消费者线程
 */
class Consumer implements Runnable {

    private List list;

    public Consumer(List list) {
        this.list = list;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (list) {
                while (list.size() < 1) {
                    try {
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " " + list.remove(0));
                list.notifyAll();//唤醒此对象锁所有等待线程（消费者和生产者线程均有）
            }
        }
    }

}

输出结果：

生产者线程0 - produce:  83
消费者线程3 - consume:  83
生产者线程3 - produce:  32
消费者线程0 - consume:  32
生产者线程2 - produce:  24
消费者线程0 - consume:  24
生产者线程3 - produce:  55
消费者线程2 - consume:  55
生产者线程0 - produce:  98
消费者线程3 - consume:  98
生产者线程3 - produce:  52
消费者线程0 - consume:  52
生产者线程1 - produce:  8
消费者线程0 - consume:  8
生产者线程3 - produce:  52
消费者线程2 - consume:  52

2、ReentrantLock 和 BlockingQueue

采用两把锁，实现生产者和消费者同时作业。需要注意的是，生产者的一个锁对象，消费者一个锁对象。分别用来唤醒消费者和生产者。

代码实现：

多条生产者和消费者随机交替，也就是说只要队列没有满那一直生产，只要队列没有空那就一直消费。

package com.thread.producerAndConsumer;

import java.util.Queue;
import java.util.Random;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author riemann
 * @date 2019/07/20 1:17
 */
public class ProducerAndConsumer3 {

    public static void main(String[] args) {
        LinkedBlockingDeque<Integer> queue = new LinkedBlockingDeque<>();
        ReentrantLock put = new ReentrantLock();
        Condition notFull = put.newCondition();
        ReentrantLock out = new ReentrantLock();
        Condition notEmpty = out.newCondition();
        for (int i = 0; i < 4; i++) {
            new Thread(new Producer(put, out ,notFull, notEmpty, queue),"生产者线程" + i +" - produce: ").start();
            new Thread(new Consumer(put, out ,notFull, notEmpty, queue),"消费者线程" + i +" - consume: ").start();
        }
    }

}

/**
 * 生产者
 */
class Producer implements Runnable {

    ReentrantLock put;
    ReentrantLock out;
    Condition notFull;
    Condition notEmpty;
    Queue<Integer> queue;

    public Producer(ReentrantLock put, ReentrantLock out, Condition notFull, Condition notEmpty, Queue<Integer> queue) {
        this.put = put;
        this.out = out;
        this.notFull = notFull;
        this.notEmpty = notEmpty;
        this.queue = queue;
    }

    @Override
    public void run() {
        Random random = new Random();
        while (true) {
            put.lock();
            while (queue.size() == 10) {
                try {
                    notFull.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Integer integer = random.nextInt(100);
            queue.add(integer);
            System.out.println(Thread.currentThread().getName() + " " + integer +", 当前Queue还剩" + queue.size());
            //队列没有满，通知更多生产者来生产
            if (queue.size() < 10) {
                notFull.signal();
            }
            put.unlock();
            //只要生产出一个就通知消费者消费，后续不需要通知
            //因为消费者内部有唤醒更多消费者的机制
            if (queue.size() == 1) {
                out.lock();
                notEmpty.signal();
                out.unlock();
            }
        }
    }

}

/**
 * 消费者
 */
class Consumer implements Runnable {

    ReentrantLock put;
    ReentrantLock out;
    Condition notFull;
    Condition notEmpty;
    Queue<Integer> queue;
    public Consumer(ReentrantLock put, ReentrantLock out, Condition notFull, Condition notEmpty, Queue queue){
        this.put=put;
        this.out=out;
        this.notFull=notFull;
        this.notEmpty=notEmpty;
        this.queue=queue;
    }

    @Override
    public void run() {
        while (true) {
            out.lock();
            while (queue.size() == 0) {
                try {
                    notEmpty.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " "+ queue.poll() + ", " + "当前Queue还剩" + queue.size());
            //只要队列里还有元素，就通知更多消费者来消费
            if (queue.size() > 0) {
                notEmpty.signal();
            }
            out.unlock();
            //只要队列没有满，就通知生产者进行生产
            if (queue.size() == 9) {
                put.lock();
                notFull.signal();
                put.unlock();
            }
        }
    }

}

输出结果：

生产者线程0 - produce:  31, 当前Queue还剩1
生产者线程1 - produce:  28, 当前Queue还剩2
消费者线程0 - consume:  31, 当前Queue还剩1
生产者线程3 - produce:  40, 当前Queue还剩2
消费者线程0 - consume:  28, 当前Queue还剩1
生产者线程3 - produce:  97, 当前Queue还剩2
消费者线程0 - consume:  40, 当前Queue还剩1
生产者线程2 - produce:  28, 当前Queue还剩1
消费者线程0 - consume:  97, 当前Queue还剩1
消费者线程0 - consume:  28, 当前Queue还剩1
生产者线程0 - produce:  13, 当前Queue还剩1
消费者线程0 - consume:  13, 当前Queue还剩1
生产者线程1 - produce:  32, 当前Queue还剩1
生产者线程1 - produce:  77, 当前Queue还剩2
消费者线程2 - consume:  32, 当前Queue还剩1
消费者线程2 - consume:  77, 当前Queue还剩1
生产者线程1 - produce:  99, 当前Queue还剩1
消费者线程1 - consume:  99, 当前Queue还剩0
生产者线程3 - produce:  38, 当前Queue还剩1
生产者线程2 - produce:  12, 当前Queue还剩1
消费者线程2 - consume:  38, 当前Queue还剩1

多条生产者和消费者，实现生产满了在消费，消费完了在生产。

package com.thread.producerAndConsumer;

import java.util.Queue;
import java.util.Random;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author riemann
 * @date 2019/07/20 1:59
 */
public class ProducerAndConsumer4 {

    public static void main(String[] args) {
        LinkedBlockingDeque<Integer> queue = new LinkedBlockingDeque<>();
        ReentrantLock put = new ReentrantLock();
        Condition notFull = put.newCondition();
        ReentrantLock out = new ReentrantLock();
        Condition notEmpty = out.newCondition();
        for (int i = 0; i < 4; i++) {
            new Thread(new Producer(put, out ,notFull, notEmpty, queue),"生产者线程" + i +" - produce: ").start();
            new Thread(new Consumer(put, out ,notFull, notEmpty, queue),"消费者线程" + i +" - consume: ").start();
        }
    }

}

/**
 * 生产者
 */
class Producer implements Runnable {

    ReentrantLock put;
    ReentrantLock out;
    Condition notFull;
    Condition notEmpty;
    Queue<Integer> queue;

    public Producer(ReentrantLock put, ReentrantLock out, Condition notFull, Condition notEmpty, Queue<Integer> queue) {
        this.put = put;
        this.out = out;
        this.notFull = notFull;
        this.notEmpty = notEmpty;
        this.queue = queue;
    }

    @Override
    public void run() {
        Random random = new Random();
        while (true) {
            put.lock();
            while (queue.size() == 10) {
                try {
                    notFull.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Integer integer = random.nextInt(100);
            queue.add(integer);
            System.out.println(Thread.currentThread().getName() + " " + integer +", 当前Queue还剩" + queue.size());
            //队列没有满，通知更多生产者来生产
            if (queue.size() < 10) {
                notFull.signal();
            }
            put.unlock();
            // 当队列已满时才通知消费者进行消费
            if (queue.size() == 10) {
                out.lock();
                notEmpty.signal();
                out.unlock();
            }
        }
    }

}

/**
 * 消费者
 */
class Consumer implements Runnable {

    ReentrantLock put;
    ReentrantLock out;
    Condition notFull;
    Condition notEmpty;
    Queue<Integer> queue;
    public Consumer(ReentrantLock put, ReentrantLock out, Condition notFull, Condition notEmpty, Queue queue){
        this.put=put;
        this.out=out;
        this.notFull=notFull;
        this.notEmpty=notEmpty;
        this.queue=queue;
    }

    @Override
    public void run() {
        while (true) {
            out.lock();
            while (queue.size() == 0) {
                try {
                    notEmpty.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " "+ queue.poll() + ", " + "当前Queue还剩" + queue.size());
            //只要队列里还有元素，就通知更多消费者来消费
            if (queue.size() > 0) {
                notEmpty.signal();
            }
            out.unlock();
            //当队列为空时，通知生产者进行生产
            if (queue.size() == 0) {
                put.lock();
                notFull.signal();
                put.unlock();
            }
        }
    }

}

输出结果：

生产者线程0 - produce:  87, 当前Queue还剩1
生产者线程0 - produce:  62, 当前Queue还剩2
生产者线程0 - produce:  8, 当前Queue还剩3
生产者线程1 - produce:  15, 当前Queue还剩4
生产者线程1 - produce:  40, 当前Queue还剩5
生产者线程2 - produce:  77, 当前Queue还剩6
生产者线程3 - produce:  48, 当前Queue还剩7
生产者线程0 - produce:  81, 当前Queue还剩8
生产者线程1 - produce:  56, 当前Queue还剩9
生产者线程1 - produce:  50, 当前Queue还剩10
消费者线程1 - consume:  87, 当前Queue还剩9
消费者线程1 - consume:  62, 当前Queue还剩8
消费者线程3 - consume:  8, 当前Queue还剩7
消费者线程3 - consume:  15, 当前Queue还剩6
消费者线程3 - consume:  40, 当前Queue还剩5
消费者线程3 - consume:  77, 当前Queue还剩4
消费者线程0 - consume:  48, 当前Queue还剩3
消费者线程0 - consume:  81, 当前Queue还剩2
消费者线程0 - consume:  56, 当前Queue还剩1
消费者线程0 - consume:  50, 当前Queue还剩0
生产者线程1 - produce:  81, 当前Queue还剩1
生产者线程1 - produce:  26, 当前Queue还剩2
生产者线程1 - produce:  72, 当前Queue还剩3
生产者线程1 - produce:  45, 当前Queue还剩4
生产者线程2 - produce:  66, 当前Queue还剩5
生产者线程2 - produce:  96, 当前Queue还剩6
生产者线程2 - produce:  95, 当前Queue还剩7
生产者线程2 - produce:  34, 当前Queue还剩8
生产者线程2 - produce:  65, 当前Queue还剩9
生产者线程2 - produce:  48, 当前Queue还剩10
消费者线程0 - consume:  81, 当前Queue还剩9
消费者线程0 - consume:  26, 当前Queue还剩8
消费者线程0 - consume:  72, 当前Queue还剩7
消费者线程0 - consume:  45, 当前Queue还剩6
消费者线程1 - consume:  66, 当前Queue还剩5
消费者线程1 - consume:  96, 当前Queue还剩4
消费者线程1 - consume:  95, 当前Queue还剩3
消费者线程2 - consume:  34, 当前Queue还剩2
消费者线程2 - consume:  65, 当前Queue还剩1
消费者线程3 - consume:  48, 当前Queue还剩
老周聊架构
关注
专栏目录
Linux高级编程基础——线程之多线程实现生产者消费者
那个那的博客
11-11 1572
用多线程实现生产者消费者： 内容比较搞笑生动，更容易理解，有什么不懂得可以在下面留言 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;pthread.h&gt; #include &lt;unistd.h&gt; #include &lt;sys/types.h&gt; int count = 1; pthr...
67、Go语言并发编程：生产者-消费者模式深度解析
silenceallat的博客
06-25 807
本文深入探讨了Go语言中的并发模式——生产者-消费者模式，通过实际案例展示了如何使用Go的通道和协程实现并发生产者和消费者。我们还介绍了如何处理缓冲区溢出和消费者错误，并探讨了生产者-消费者模式的进阶应用，包括优先级处理和工作窃取算法。这些内容帮助读者更好地理解并发编程原理，提升项目性能和效率。
多线程-生产者和消费者模式的四种实现
Fly_Fly_Zhang的博客
05-29 6814
什么是生产者和消费者模式： 生产者和消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此并不直接通信，而是通过阻塞队列进行通信，所以生产者生产完数据后不用等待消费者进行处理，而是直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列中获取数据，阻塞队列就相当于一个缓冲区，平衡生产者和消费者的处理能力。 wait/notify和synchronized配合实现： 生产者...
【转】-Java实现生产者和消费者的5种方式
最新发布
booleandev
07-10 1210
生产者和消费者问题是线程模型中的经典问题：生产者和消费者在同一时间段内共用同一个存储空间，生产者往存储空间中添加产品，消费者从存储空间中取走产品，当存储空间为空时，消费者阻塞，当存储空间满时，生产者阻塞。现在用四种方式来实现生产者消费者模型。
【Java并发编程】之十三：生产者—消费者模型（含代码）
技术崛起
03-28 527
生产者消费者问题是线程模型中的经典问题：生产者和消费者在同一时间段内共用同一存储空间，生产者向空间里生产数据，而消费者取走数据。     这里实现如下情况的生产--消费模型：     生产者不断交替地生产两组数据“姓名--1 --> 内容--1”，“姓名--2--> 内容--2”，消费者不断交替地取得这两组数据，这里的“姓名--1”和“姓名--2”模拟为数据的名称，“内容--1 ”
多线程实现生产者消费者
Achiberx
06-13 415
一、采用synchronized锁以及wait notify方法实现/** * 1.wait()的作用是让当前线程进入等待状态，同时，wait()也会让当前线程释放它所持有的锁。“直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法”，当前线程被唤醒(进入“就绪状态”) * 2.notify()和notifyAll()的作用，则是唤醒当前对象上的等待线程；notify
多线程实现生产者消费者模型
祁_z
08-09 432
整体思路： 1. 定义一个容量大小为10的Queue堵塞队列，用于存储消息； 2. 生产者通过while死循环将消息投递到Queue中，如果Queue长度等于Queue最大容量则通过wait()进行等待； 3. 消费者通过while死循环消费Queue数据，并notify()释放（生产者即可继续投递消息）; 注意：wait()和notify()只能用在同步代码块中；并且生产者、消费者中的同步代码块都要锁同一个Goods.queue对象. 首先定义一个实体类 /** * 实体类 */ pub
Java多线程生产者消费者模式实现过程解析
08-19
Java多线程生产者消费者模式是指在Java编程中，使用多线程来实现生产者和消费者之间的数据交换 и处理的模式。该模式下，生产者负责产生数据，而消费者负责处理数据。这种模式可以提高系统的性能和效率，特别是在高...
JAVA多线程实现生产者消费者的实例详解
08-30
生产者消费者模型是指在计算机科学中的一种经典模式，描述了生产者和消费者之间的协作关系。在这个模型中，生产者负责生产产品，而消费者负责消费产品。 在JAVA中，实现生产者消费者模型可以使用多线程技术，即生产...
Lock、Condition实现简单的生产者消费者模式示例
09-04
在Java多线程编程中，生产者消费者模式是一种常见的设计模式，用于协调生产者线程和消费者线程之间的协作，确保资源的有效利用和同步。在这个示例中，使用了Java的`java.util.concurrent.locks`包中的`Lock`接口和`...
详解Python 模拟实现生产者消费者模式的实例
09-21
生产者消费者模式是一种多线程或并发编程中的经典设计模式，用于解决生产者（producer）与消费者（consumer）之间的同步问题。在这个模式中，生产者负责生成数据并放入缓冲区，而消费者则从缓冲区取出数据进行处理。...
Java多线程实现生产者消费者
05-29
编写一个“生产者-消费者”的多线程演示程序，两个生产者，一个消费者，可以存放产品的仓库容量为10，仓库用栈实现，并有同步功能，且能防止先消费后生产的情况。
多线程模拟实现生产者／消费者模型
04-20
NULL 博文链接：https://rd-030.iteye.com/blog/1874400
java多线程实现生产者和消费者
12-22
java多线程实现生产者和消费者 ，4种实现方式，分别为synchronizated，condition和lock，信号量，阻塞队列
多线程简易实现生产者消费者模式
11-09
用java多线程简易实现生产者消费者模式的代码，用java多线程简易实现生产者消费者模式的代码。
Java多线程实现生产者消费者模式
geilidashen的博客
07-28 628
用java实现生产者消费者模式，在全部代码之后会对重点、难点一一讲解！ 以下是全部代码：class Demo7 { public static void main(String[] args) { //资源对象 Resource r = new Resource(); //生产者 Producer pro = new Prod
使用多线程实现生产者与消费者模式
weixin_41798125的博客
11-10 372
本小白死而复生，又回来了。 今天讲一下线程基础。使用多线程实现生产者与消费者模式来模拟一个存取钱的过程。愿各位大神，大佬多多指教。 我们一般同步用synchronized,如果你想要用高级一点的,用lock,但别忘了释放一下,不理会发生死锁的哦,同学。 另外，* sleep 与 wait的区别? sleep:让线程进入休眠状态,让出CPU的时间片,不释放对象监视器的所有权。 wait:让线程进入...
Java多线程实现生产者消费者（简易版）
weixin_51955084的博客
06-01 2471
生产者消费者问题
多线程实现生产者和消费者模型
fw150104010012的博客
10-10 240
多线程，生产者消费者模型
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

老周聊架构

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值