进程间通讯-消息队列和信号灯

已于 2022-10-19 02:35:48 修改
阅读量189 收藏
点赞数
分类专栏： Linux 进程间通信 文章标签： c语言 linux
于 2022-10-19 02:35:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sure0/article/details/127397374
版权

消息队列

  • 消息队列是System V IPC对象的一种
  • 消息队列由消息队列ID来唯一标识
  • 消息队列就是一个消息的列表。用户可以在消息队列中添加消息、读取消息等
  • 消息队列可以按照类型来发送/接收消息

消息队列结构

消息队列使用步骤

发送端：

        1 申请Key

        2打开/创建消息队列   msgget

        3向消息队列发送消息   msgsnd

接收端：

        1打开/创建消息队列   msgget

        2从消息队列接收消息   msgrcv

        3 控制（删除）消息队列   msgctl

消息队列创建/打开 – msgget

 #include <sys/ipc.h>

#include <sys/msg.h>  

int msgget(key_t key, int msgflg);

 

成功时返回消息队列的id，失败时返回EOF  

key 和消息队列关联的key  IPC_PRIVATE 或 ftok  

msgflg  标志位  IPC_CREAT|0666

消息发送 – msgsnd

 #include <sys/ipc.h>  

#include <sys/msg.h>  

int msgsnd(int msgid, const void *msgp, size_t size, int msgflg);    

成功时返回0，失败时返回-1  

msgid   消息队列id  

msgp    消息缓冲区地址  

size    消息正文长度  

msgflg   标志位 0 或 IPC_NOWAIT

消息格式

  • 通信双方首先定义好统一的消息格式
  • 用户根据应用需求定义结构体类型
  • 首成员类型必须为long,代表消息类型(正整数)
  • 其他成员都属于消息正文
  • 消息长度不包括首类型 long

typedef struct{

                long msg_type;

                char buf[128];

}msgT;

消息接收 – msgrcv

 #include <sys/ipc.h>  

#include <sys/msg.h>

int msgrcv(int msgid, void *msgp, size_t size, long msgtype,int msgflg);  

成功时返回收到的消息长度，失败时返回-1  

msgid   消息队列id  

msgp   消息缓冲区地址  

size   指定接收的消息长度  

msgtype   指定接收的消息类型  

  •         msgtype=0：收到的第一条消息，任意类型。
  •         msgtype>0：收到的第一条 msg_type类型的消息。
  •         msgtype<0：接收类型等于或者小于msgtype绝对值的第一个消息。

        例子：如果msgtype=-4，只接受类型是1、2、3、4的消息

 

msgflg   标志位   0 或 IPC_NOWAIT

  •         0：阻塞式接收消息
  •         IPC_NOWAIT：如果没有返回条件的消息调用立即返回，此时错误码为ENOMSG
  •         MSG_EXCEPT：与msgtype配合使用返回队列中第一个类型不为msgtype的消息

控制消息队列 – msgctl

 #include <sys/ipc.h>  

#include <sys/msg.h>  

int msgctl(int msgid, int cmd, struct msqid_ds *buf);  

成功时返回0，失败时返回-1  

msgid    消息队列id  

cmd    要执行的操作  IPC_STAT / IPC_SET / IPC_RMID  

buf   存放消息队列属性的地址

消息队列收发数据代码实例

发送数据-msgsnd.c

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>

typedef struct{
    long msg_type;
    char buf[128];
}msgT;    

#define MSGLEN  (sizeof(msgT)-sizeof(long))

int main(){
    key_t key;
    int msgid;
    int ret;
    msgT msg;
    key = ftok(".",100);
    if(key<0){
        perror("ftok");
        return 0;
    }
    msgid = msgget(key,IPC_CREAT|0666);
    if(msgid<0){
        perror("msgget");
        return 0;
    }

    msg.msg_type = 1;
    strcpy(msg.buf,"this msg type 1");
    ret = msgsnd(msgid,&msg,MSGLEN,0);
    if(ret<0){
        perror("msgsnd");
        return 0;
    }    

    msg.msg_type = 2;
    strcpy(msg.buf,"this msg type 2");
    ret = msgsnd(msgid,&msg,MSGLEN,0);
    if(ret<0){
        perror("msgsnd");
        return 0;
    }
    msg.msg_type = 3;
    strcpy(msg.buf,"this msg type 3");
    ret = msgsnd(msgid,&msg,MSGLEN,0);
    if(ret<0){
        perror("msgsnd");
        return 0;
    }
    msg.msg_type = 4;
    strcpy(msg.buf,"this msg type 4");
    ret = msgsnd(msgid,&msg,MSGLEN,0);
    if(ret<0){
        perror("msgsnd");
        return 0;
    }
    msg.msg_type = 5;
    strcpy(msg.buf,"this msg type 5");
    ret = msgsnd(msgid,&msg,MSGLEN,0);
    if(ret<0){
        perror("msgsnd");
        return 0;
    }
}

接收数据-msgrcv.c

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>

typedef struct{
    long msg_type;
    char buf[128];
}msgT;    

#define MSGLEN  (sizeof(msgT)-sizeof(long))
int main(){
    
    int msgid;
    key_t key;
    msgT msg;
    int ret;
    key = ftok(".",100);
    if(key<0){
        perror("ftok");
        return 0;
    }    
    msgid = msgget(key,IPC_CREAT|0666);
    if(msgid<0){
        perror("msgget");
        return 0;
    }
    int count=0;
    while(1){
        ret = msgrcv(msgid,&msg,MSGLEN,0,0);
        if(ret<0){
            perror("msgrcv");
            return 0;
        } 
        count++;
        if(count>3){
            break;
        }
        printf("receiv msg type=%d,buf=%s\n",(int)msg.msg_type,msg.buf);
    }

    ret = msgctl(msgid,IPC_RMID,NULL);
    if(ret<0){
        perror("msgctl");
        return 0;
    }    

}

信号灯/信号量（semaphore）

概念：是不同进程间或一个给定进程内部不同线程间同步的机制。类似我们的

PV操作概念：生产者和消费者场景

Ｐ(Ｓ) 含义如下:

 if  (信号量的值大于0)

{  

        申请资源的任务继续运行；

        信号量的值减一；

}

else

{   

        申请资源的任务阻塞；

}

V(Ｓ) 含义如下:

信号量的值加一；

if (有任务在等待资源)

{   

        唤醒等待的任务，让其继续运行

}

Posix  信号量

posix中定义了两类信号量：

  • 无名信号量(基于内存的信号量,linux仅支持线程同步)
  • 有名信号量

Posix 有名信号灯和无名信号灯使用：

有名信号灯的使用

有名信号灯打开：

sem_t *sem_open(const char *name, int oflag);

sem_t *sem_open(const char *name, int oflag,mode_t mode, unsigned int value);

参数：

name：name是给信号灯起的名字

oflag：打开方式，常用O_CREAT

mode：文件权限。常用0666

value：信号量值。二元信号灯值为1，普通表示资源数目

信号量 – P / V 操作

 #include  <semaphore.h>  

int  sem_wait(sem_t  *sem);       P操作  

int  sem_post(sem_t  *sem);       V操作  

成功时返回0，失败时返回EOF  

sem  指向要操作的信号量对象

信号灯文件位置：

/dev/shm

有名信号灯关闭

int sem_close(sem_t *sem);

有名信号灯的删除

int sem_unlink(const char* name);

有名信号量实现两个进程间对同一个共享内存的读写同步的代码实例

sem_w.c

#include <fcntl.h>           /* For O_* constants */
#include <sys/stat.h>        /* For mode constants */
#include <semaphore.h>

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <signal.h>


void delsemfile(int sig){
    sem_unlink("mysem_w");
    exit(0);

}

int main(){


   sem_t *sem_r,*sem_w;
   key_t key;
   int shmid;
   char *shmaddr;

   struct sigaction act;
   act.sa_handler = delsemfile;
   act.sa_flags = 0;
   sigemptyset(&act.sa_mask);

   sigaction(SIGINT,&act,NULL);

   key = ftok(".",100);
   if(key<0){
       perror("ftok");
       return 0;
   }

   shmid = shmget(key,500,0666|IPC_CREAT);
   if(shmid<0){
       perror("shmget");
       return 0;
   }

   shmaddr = shmat(shmid,NULL,0);
   
   sem_r = sem_open("mysem_r",O_CREAT|O_RDWR,0666,0);
   sem_w = sem_open("mysem_w",O_CREAT|O_RDWR,0666,1);

   while(1){
        sem_wait(sem_w);
        printf(">");
        fgets(shmaddr,500,stdin);
        sem_post(sem_r);
   }

}

sem_r.cr

#include <fcntl.h>           /* For O_* constants */
#include <sys/stat.h>        /* For mode constants */
#include <semaphore.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <signal.h>


void delsemfile(int sig){
    sem_unlink("mysem_r");
    exit(0);

}


int main(){

   sem_t *sem_r,*sem_w;
   key_t key;
   int shmid;
   char *shmaddr;
   struct sigaction act;
   act.sa_handler = delsemfile;
   act.sa_flags = 0;
   sigemptyset(&act.sa_mask);

   sigaction(SIGINT,&act,NULL);



   key = ftok(".",100);
   if(key<0){
       perror("ftok");
       return 0;
   }

   shmid = shmget(key,500,0666|IPC_CREAT);
   if(shmid<0){
       perror("shmget");
       return 0;
   }

   shmaddr = shmat(shmid,NULL,0);
   
   sem_r = sem_open("mysem_r",O_CREAT|O_RDWR,0666,0);
   sem_w = sem_open("mysem_w",O_CREAT|O_RDWR,0666,1);

   while(1){
        sem_wait(sem_r);
        printf("%s\n",shmaddr);
        sem_post(sem_w);
   }

}

无名信号灯的使用（只能线程间使用）

pthread库常用的信号量操作函数如下：

  • int sem_init(sem_t *sem,  int pshared,  unsigned int value);
  • int sem_wait(sem_t *sem);   //  P操作
  • int sem_post(sem_t *sem);  // V操作

信号量初始化 – sem_init

 #include  <semaphore.h>  

int  sem_init(sem_t *sem, int pshared, unsigned int val);  

成功时返回0，失败时EOF  

sem  指向要初始化的信号量对象  

pshared   0 – 线程间   1 – 进程间  

val  信号量初值


无名信号灯销毁

int sem_destroy(sem_t* sem);

无名信号量实现两个线程间对同一个共享内存的读写同步的代码实例

#include <fcntl.h>           /* For O_* constants */
#include <sys/stat.h>        /* For mode constants */
#include <semaphore.h>

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <signal.h>
#include <pthread.h>


sem_t sem_r,sem_w;
char *shmaddr;
void destroysem(int sig){
//    sem_unlink("mysem_w");
   sem_destroy(&sem_r);
   sem_destroy(&sem_w);
   exit(0);

}

void *readmem(void *arg){
    while(1){
        sem_wait(&sem_r);
        printf("%s\n",shmaddr);
        sem_post(&sem_w);

    }

}


int main(){


   key_t key;
   int shmid;

   struct sigaction act;
   act.sa_handler = destroysem;
   act.sa_flags = 0;
   sigemptyset(&act.sa_mask);

   sigaction(SIGINT,&act,NULL);

   key = ftok(".",100);
   if(key<0){
       perror("ftok");
       return 0;
   }

   shmid = shmget(key,500,0666|IPC_CREAT);
   if(shmid<0){
       perror("shmget");
       return 0;
   }

   shmaddr = shmat(shmid,NULL,0);
   
//   sem_r = sem_open("mysem_r",O_CREAT|O_RDWR,0666,0);
//   sem_w = sem_open("mysem_w",O_CREAT|O_RDWR,0666,1);
   sem_init(&sem_r,0,0);
   sem_init(&sem_w,0,1);

   pthread_t tid;
   pthread_create(&tid,NULL,readmem,NULL);
    
   while(1){
        sem_wait(&sem_w);
        printf(">");
        fgets(shmaddr,500,stdin);
        sem_post(&sem_r);
   }

}

System V IPC - 信号灯

        信号灯也叫信号量，用于进程/线程同步或互斥的机制

信号灯的类型  

  • Posix 无名信号灯  
  • Posix有名信号灯  
  • System V  信号灯

信号灯的含义  

  • 计数信号灯

System V IPC - 信号灯特点

  • System V 信号灯是一个或多个计数信号灯的集合
  • 可同时操作集合中的多个信号灯
  • 申请多个资源时避免死锁

System V信号灯使用步骤

  1. 打开/创建信号灯  
  2. semget 信号灯初始化  
  3. semctl P/V操作   semop
  4. 删除信号灯  semctl

信号灯创建/打开 – semget

 #include <sys/ipc.h>  

#include <sys/sem.h>  

int semget(key_t key, int nsems, int semflg);  

成功时返回信号灯的id，失败时返回-1  

key   和消息队列关联的key  IPC_PRIVATE 或 ftok  

nsems   集合中包含的计数信号灯个数  

semflg   标志位  IPC_CREAT|0666   IPC_EXCL

信号灯初始化 – semctl

#include <sys/ipc.h>

#include <sys/sem.h>

int semctl(int semid, int semnum, int cmd, …);  

成功时返回0，失败时返回EOF  

semid    要操作的信号灯集id  

semnum   要操作的集合中的信号灯编号  

cmd   执行的操作  SETVAL  IPC_RMID  

union  semun      取决于cmd

信号灯P/V操作 – semop

#include <sys/ipc.h>

#include <sys/sem.h>

int semop(int semid, struct sembuf *sops, unsigned nsops);  

成功时返回0，失败时返回-1  

semid    要操作的信号灯集id  

sops    描述对信号灯操作的结构体(数组)  

nsops   要操作的信号灯的个数

信号灯操作 – sembuf

 struct  sembuf  

{      

        short  sem_num;      

        short  sem_op;      

        short  sem_flg;

 };  

semnum         信号灯编号  

sem_op           -1：P操作   1：V操作

sem_flg           0 / IPC_NOWAIT

#include <semaphore.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>

#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <sys/sem.h>


#define SEM_READ   0
#define SEM_WRITE  1

union semun {
   int val;
};               

void Poperation(int semid,int semindex){
   struct sembuf sbuf;
   sbuf.sem_num =  semindex;
   sbuf.sem_op = -1;
   sbuf.sem_flg = 0;

   semop(semid,&sbuf,1);


}
void Voperation(int semid,int semindex){
   struct sembuf sbuf;
   sbuf.sem_num =  semindex;
   sbuf.sem_op = 1;
   sbuf.sem_flg = 0;
              
   semop(semid,&sbuf,1);


}



int main(){

    key_t key;
    char *shmaddr;
    int semid,shmid;
    key = ftok(".",100);
    if(key<0){
        perror("ftok");
        return 0;
    }
    
    semid = semget(key,2,IPC_CREAT |0666);
    if(semid<0){
        perror("semget");
        return 0;
    }
    shmid = shmget(key,500,IPC_CREAT |0666);
    shmaddr = shmat(shmid,NULL,0);
    union semun mysem;
    mysem.val = 0;
    semctl(semid,SEM_READ,SETVAL,mysem);
    mysem.val = 1;
    semctl(semid,SEM_WRITE,SETVAL,mysem);

    pid_t pid;
    pid = fork();
    if(pid<0){
        perror("fork");
        shmctl(shmid,IPC_RMID,NULL);
        semctl(semid,0,IPC_RMID);
        exit(-1);
    }else if(pid == 0){
        while(1){
            Poperation(semid,SEM_READ);
            printf("%s\n",shmaddr);

            Voperation(semid,SEM_WRITE);

        }
 

    }else{
        while(1){
            Poperation(semid,SEM_WRITE);
            printf(">");
            fgets(shmaddr,32,stdin);

            Voperation(semid,SEM_READ);

        }

    }

}

sure0
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
CVI编的安全队列代码
04-10
多线程的通信，用安全队列来防止两线程数据的丢失！希望对大家有所帮助！
进程间通信之信号灯（信号量）
m0_51274562的博客
08-15 267
在多个进程同时执行在执行通信时，由写部分必须有先后，为了保证按照指定的要求进行执行，这个时候就引入了生产者消费者模型。生产者：就是制作一个可以通信的标志位，对标志位进行++操作，从而生产资源，也可理解为（释放资源，进V操作）。消费者：顾名思义就是当生产者生产过后，其标志位发生变化，然后操作之后进行消费（其实信号灯的操作就是这样，消费者随时去查看生产者生产没有，生产力消费者就消费。在进程间通信的时候，需要将读程序和写程序都要进行运行才可以，否则不会进行工作。信号灯读操作，和写差距不大。......
FreeRTOS个人笔记-消息队列
weixin_47077788的博客
07-24 1518
根据个人的学习方向，学习FreeRTOS。由于野火小哥把FreeRTOS讲得比较含蓄，打算在本专栏尽量细化一点。作为个人笔记，仅供参考或查阅。配套资料FreeRTOS内核实现与应用开发实战指南、野火FreeRTOS配套视频源码、b站野火FreeRTOS视频。搭配来看更佳哟！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！
FreeRTOS五种方式传递信号（队列，信号量，互斥量，事件组，任务通知）
电子第一课，点亮LED；第二课，点亮钽电容；第三课，点亮MOS管
07-15 1983
在裸机编程中，一般信号传递都是全局变量，数组或者是返回值函数等等其他方式，在freertos中，我们不再使用裸机编程方式，而是使用统一的（五种）方式传递信号量，更加规范的，安全，传递（通知）信号。
进程间通信方式的优缺点
m0_69124108的博客
02-15 717
进程间通信方式的优缺点
Linux进程间通信-消息队列实例.pdf
07-11
Linux进程间通信-消息队列实例.pdf 学习资料 复习资料 教学资源
C#进程间通信-消息队列代码实例
12-04
C#进程间通信-消息队列代码实例。用实现了2个进程，他们之间使用消息队列方式进行通信。
PHP多进程通信-消息队列使用
10-17
主要介绍了PHP通信-消息队列使用详解，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
实验53 UCOSII实验3-消息队列、信号量集和软件定时器USER.zip
05-05
UCOSII实验3-消息队列、信号量集和软件定时器USER
Linux进程间通信：消息队列
01-20
消息队列允许一个或多个进程向它写入与读取消息. 　3.管道和命名管道都是通信数据都是先进先出的原则。 　4.消息队列可以实现消息的随机查询，消息不一定要以先进先出的次序读取，也可以按消息的类型读取.比FIFO更...
【Linux多线程】三个经典同步问题
dbbaq24022的专栏
04-30 402
在了解了《同步与互斥的区别 》之后，我们来看看几个经典的线程同步的例子。相信通过具体场景可以让我们学会分析和解决这类线程同步的问题，以便以后应用在实际的项目中。 一、生产者-消费者问题 问题描述： 一组生产者进程和一组消费者进程共享一个初始为空、大小为 n 的缓冲区，只有缓冲区没满时，生产者才能把消息放入到缓冲区，否则必须等待；只有缓冲区不空时，消费者才能从...
struct sembuf的部分讲解
wanzyao的博客
02-16 6778
sembuf结构体的定义如下： [cpp] view plain copy  print? struct sembuf   {     unsigned short int sem_num;   /* 信号量的序号从0~nsems-1 */     short int sem_op;            /* 对信号量的操作，>0, 0,
CVI多线程数据保护（安全队列）
思维逆逝
10-09 3089
一个线程产生数据，加入安全队列；一个线程显示数据，读取安全队列。 #include #include #include int CVICALLBACK ThreadFunction (void *functionData); int CVICALLBACK ThreadFunction1 (void *functionData); int threadID; int threadID1
LabWindows/CVI入门之第二章：GUI开发
热门推荐
世事洞明皆学问
01-19 1万+
转自：http://blog.sina.com.cn/s/blog_6373e9e60101bps5.html 2.1 六步构建简单的GUI程序       在本节中，我们要做的例子很简单，是创建一个如下图所示的应用程序。 图 2‑1 程序运行效果   2.1.1 创建工程文件     运行LabWindows/CVI，单击菜单File-
struct sembuf结构体
Daemon_的博客
07-17 8545
sembuf结构体中的元素 struct sembuf{ short sem_num; short sem_op; short sem_flg; }; •sem_num是信号量的编号，如果你的工作不需要使用一组信号量，这个值一般就取为0。 •sem_op是信号量一次PV操作时加减的数值，一般只会用到两个值，一个是“－1”，也就是P操作，等待信号量变得可用；另一个是“＋1”，也就是我们的
Linux进程间通信/多线程通信——信号量
Biao
07-29 1865
前言： 信号量在进程中和在线程中有不同的接口实现，使用信号量来做多进程间同步与使用信号量来做多线程间的同步是不一样的，这里将分别介绍信号量在多进程和多线程中的应用。 信号量在多进程中的应用： 这篇文章将讲述别一种进程间通信的机制——信号量。注意请不要把它与之前所说的信号混淆起来，信号与信号量是不同的两种事物。有关信号的更多内容，可以阅读我的另一篇文章：Linux进程间通信——...
【总结】Linux内核剖析-------进程及其通信
从底层爬
04-30 228
进程 ref：https://blog.csdn.net/RUN32875094/article/details/79328531 https://blog.csdn.net/lixungogogo/article/details/52202714 1.进程的四要素： 一、进程有需要执行的代码，也就是CPU指令和被操作的数据。代码相当于进程的剧本，可以和其他进程共用，不一定是该进程...
进程间的通信---信号灯
刘先森的博客
11-17 797
信号灯，也叫信号量，它是不同进程间或一个给定进程内部不同线程间同步机制。 信号灯的使用一般配合共享内存使用，用以实现同步和互斥； 编写步骤： 1.使用ftok()函数获取key值； 2.使用semget()函数创建一个信号灯；（注：在这之前必须要把共享内存创建好，具体方法上篇博客有详细方法） 3.使用semctl()函数初始化信号量，（注：在这之前要先定义一个共用体，在Linux里可以通
消息队列 信号灯 共享内存
clh820的博客
02-26 496
1. 消息队列答：队列就是一个消息的链表。可以把消息看作一个记录,具有特定的格式及特定的优级。对消息队列有写权限的进程可以向中按照一定的规则添加新消息,对消息队列有读权限的进程则可以从消息队列中读走消息,消息队列是随内核持续的。 2. 消息队列的操作有下面三种类型答：(1) 打开或创建消息队列。消息队列的内核持续性要求每个消息队列都在系统范围內对应唯一的键值,所以,要获得一个消息队列的描述字,只需...
qt 进程间通讯 消息队列
最新发布
08-31
消息队列具有以下特征：可以设置最大消息个数和每个消息的最大字节数，可以向消息队列中写入多条消息，而其他进程读取一条消息后，消息队列就会删除这条消息。 要发送消息到消息队列中，可以使用mq_send函数。该...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值