linux定时中断的三种实现

最新推荐文章于 2024-05-26 20:44:35 发布
最新推荐文章于 2024-05-26 20:44:35 发布
阅读量1w 收藏 39
点赞数 10
分类专栏： linux系统编程 文章标签： setitimer timer_create timer_settime linux定时器 多线程信号
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014530704/article/details/81415153
版权

前言

本文主要讲述linux应用层三种定时中断实现的方法。我们可以利用定时中断在linux应用层实现一些对时间频率要求不是很高的驱动，虽然有些不规范，但是也是有其适用的场合的。因为应用层不涉及到硬件，不同平台可移植性更高。
本文涉及到的内容有：

  1. 多线程间信号的处理
  2. 三种定时中断的实现
  3. 测试结果与讨论

一、多线程间信号的处理

我们先下两个结论，并在后面的测试程序中给出证明。

  1. 结论一：默认情况下，信号将由主进程接收处理，就算信号处理函数是由子线程注册的。
  2. 结论二：对信号的处理是进程中所有的线程共享的。

为什么要先讨论线程间的信号的处理呢？这和定时中断的实现有何关系？
放在前面讨论是因为之前踩了一个坑，先把坑分享出来，以免有人掉到坑里。
在项目开发中，对步进电机的控制，一开始我使用的是linux setitimer函数，目的是为了定时给出脉冲到步进电机，实现在应用层控制马达的转动。事实证明，是能够在应用层实现的。但是，后来的测试中，其他功能报了一个错误，查看log发现是sleep函数不生效。查看相关资料才发现，他们之前都使用了同种信号，导致了sleep函数接收了setitimer函数发出的信号。是有想过用select函数实现自己的sleep函数，这样可以解决问题，而且select函数比sleep函数更加准确。但是，项目搜索出来的sleep函数实在太多了，每个都修改实在烦。所以，只能另寻他路。果然，linux还能用POSIX中内置的定时器，使用函数timer_create 和函数timer_settime可以解决上面问题。

二、定时中断的三种实现

三种定时中断实现：

  1. setitimer 函数产生SIGALRM信号，同时使用signal函数注册
  2. 使用timer_create 和 timer_settime函数可以指定任意产生任意信号，同时使用signal函数注册
  3. 使用timer_create 和 timer_settime函数 通知线程

程序实现的代码如下：

//timer_test.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <time.h>
#include <sys/time.h>
#include <string.h>


// return: 自CPU上电以来的时间，单位:毫秒
unsigned long long GetCpuRunTimeMs(void)
{
    unsigned long long  uptime = 0;
    struct timespec on;
    if(clock_gettime(CLOCK_MONOTONIC, &on) == 0)
    {
        uptime = on.tv_sec * 1000ul;
        uptime += on.tv_nsec / 1000000ul;
    }

    return uptime;
}
//信号处理函数
void signal_func(int signo)
{
    static unsigned long long start_time = 0;

    switch(signo)
    {
        case SIGALRM:
            printf("%s:1s-----> take %llu ms,signo=SIGALRM(%d)\n",__FUNCTION__,GetCpuRunTimeMs()-start_time,signo);
            break;
        case SIGUSR1:
            printf("%s:1s-----> take %llu ms,signo=SIGUSR1(%d)\n",__FUNCTION__,GetCpuRunTimeMs()-start_time,signo);
            break;
        default:
            break;
    }
    start_time = GetCpuRunTimeMs();
}
//setitimer函数相关初始化
void vTimerInit(void)
{
    struct itimerval value, old_value;

    signal(SIGALRM, signal_func);
    value.it_value.tv_sec = 1; //设置距离首次中断的时间
    value.it_value.tv_usec = 0;
    value.it_interval.tv_sec = 1; //时间间隔
    value.it_interval.tv_usec = 0;
    setitimer(ITIMER_REAL, &value, &old_value);    
}
//timer_create初始化相关，注册信号SIGUSR1
int vTimerCreateInit(void)
{
    struct sigevent evp;
    struct itimerspec ts;
    timer_t timer;
    int ret;
    memset(&evp, 0, sizeof(struct sigevent));   //清零初始化
    evp.sigev_value.sival_ptr = &timer;
    evp.sigev_notify = SIGEV_SIGNAL;
    evp.sigev_signo = SIGUSR1;
    signal(SIGUSR1, signal_func);

    ret = timer_create(CLOCK_REALTIME, &evp, &timer);
    if( ret )
        perror("timer_create");

    ts.it_interval.tv_sec = 1;
    ts.it_interval.tv_nsec = 0;
    ts.it_value.tv_sec = 1;
    ts.it_value.tv_nsec = 0;

    ret = timer_settime(timer, 0, &ts, NULL);
    if( ret )
        perror("timer_settime");

    return ret;
}

void timer_thread(union sigval v)
{
    static unsigned long long start_time = 0;

    printf("%s:1s-----> take %llu ms, v.sival_int = %d\n",__FUNCTION__,GetCpuRunTimeMs()-start_time,v.sival_int);
    start_time = GetCpuRunTimeMs();

}
//不采用信号通知的方式，直接通知线程
int vTimerPthreadInit(void)
{
    timer_t timerid;
    struct sigevent evp;
    int ret;
    memset(&evp, 0, sizeof(struct sigevent));   //清零初始化

    evp.sigev_value.sival_int = 1111;       
    evp.sigev_notify = SIGEV_THREAD;        //线程通知的方式，派驻新线程
    evp.sigev_notify_function = timer_thread;   //线程函数地址

    ret = timer_create(CLOCK_REALTIME, &evp, &timerid);
    if( ret )
        perror("timer_create");

    struct itimerspec it;
    it.it_interval.tv_sec = 1;  //间隔1s
    it.it_interval.tv_nsec = 0;
    it.it_value.tv_sec = 1;     
    it.it_value.tv_nsec = 0;

    ret = timer_settime(timerid, 0, &it, NULL);
    if( ret )
        perror("timer_settime");

    return ret;

}

//线程，用于测试信号接收
void *vTimerProc(void *arg)
{
    printf("pthread func:%s\n",__FUNCTION__);

    unsigned long long start_time = 0;
    while(1)
    {
        start_time = GetCpuRunTimeMs();
        sleep(5);
        printf("%s:sleep 5s take %llu ms\n",__FUNCTION__,GetCpuRunTimeMs()-start_time);
    }    
    return NULL;

}
//线程，用于测试信号接收
void *vSleepProc(void *arg)
{
    printf("pthread func:%s\n",__FUNCTION__);

    unsigned long long start_time = 0;
    while(1)
    {
        start_time = GetCpuRunTimeMs();
        sleep(5);
        printf("%s:sleep 5s take %llu ms\n",__FUNCTION__,GetCpuRunTimeMs()-start_time);
    }    
    return NULL;

}

//线程初始化函数
void  vPthreadInit(void)
{
    printf("func:%s\n",__FUNCTION__);

    pthread_t timer_thread_id = 0;
    pthread_create(&timer_thread_id, NULL, vTimerProc, NULL);

    pthread_t sleep_thread_id = 0;
    pthread_create(&sleep_thread_id, NULL, vSleepProc, NULL);

}

int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        printf("please input eg: %s 1|2|3\n",argv[0]);
        printf("1:user SIGALRM\n");
        printf("2:user SIGUSR1\n");
        printf("3:user thread\n");
        return -1;
    }
    printf("func:%s ,process id is %d\n",__FUNCTION__,getpid());
    struct itimerval value, old_value;
    unsigned long long start_time = 0;
    unsigned long long end_time = 0;

    int ctrl = atoi(argv[1]);
    switch(ctrl)
    {
        case 1:
            vTimerInit();
            break;
        case 2:
            vTimerCreateInit();
            break;
        case 3:
            vTimerPthreadInit();
            break;
        default:
            return -1;
            break;
    }

    vPthreadInit();

    while(1)
    {
        start_time = GetCpuRunTimeMs();
        sleep(5);
        printf("%s:sleep 5s take %llu ms\n",__FUNCTION__,GetCpuRunTimeMs()-start_time);
    }
}

以上程序 ，并没有所有函数都有做判断，如果是写到项目中，是需要加多错误判断和处理的。
以下三个函数包含了定时中断三种方式。

int vTimerPthreadInit(void)//不采用信号通知的方式，直接通知线程
int vTimerCreateInit(void)//timer_create初始化相关，注册信号SIGUSR1
int vTimerPthreadInit(void)//不采用信号通知的方式，直接通知线程

在测试程序中使用参数1,2,3区分调用。在main函数中处理如下：

int ctrl = atoi(argv[1]);
switch(ctrl)
{
    case 1:
        vTimerInit();
        break;
    case 2:
        vTimerCreateInit();
        break;
    case 3:
        vTimerPthreadInit();
        break;
    default:
        return -1;
        break;
}

三、测试结果与讨论

接下来对程序进程测试。
编译，需要加多两个库：-lpthread -lrt

ubuntu@ubuntu:~/test/timer_create$ gcc timer_test.c -o timer_test -lpthread -lrt

先执行测试一下，发现测试程序已经有提示了，按照提示来测试。

ubuntu@ubuntu:~/test/timer_create$ ./timer_test
please input eg: ./timer_test 1|2|3
1:user SIGALRM
2:user SIGUSR1
3:user thread

首先，测试setitimer函数，它在程序中会产生SIGALRM信号

ubuntu@ubuntu:~/test/timer_create$ ./timer_test 1
func:main ,process id is 7186
func:vPthreadInit
pthread func:vSleepProc
pthread func:vTimerProc
signal_func:1s-----> take 535951046 ms,signo=SIGALRM(14)
main:sleep 5s take 1000 ms
signal_func:1s-----> take 1000 ms,signo=SIGALRM(14)
main:sleep 5s take 1000 ms
signal_func:1s-----> take 1000 ms,signo=SIGALRM(14)
main:sleep 5s take 1000 ms
signal_func:1s-----> take 1000 ms,signo=SIGALRM(14)
main:sleep 5s take 1000 ms
signal_func:1s-----> take 1000 ms,signo=SIGALRM(14)
main:sleep 5s take 1000 ms
vSleepProc:sleep 5s take 5001 ms
vTimerProc:sleep 5s take 5000 ms
signal_func:1s-----> take 1000 ms,signo=SIGALRM(14)
main:sleep 5s take 1000 ms
signal_func:1s-----> take 1000 ms,signo=SIGALRM(14)
main:sleep 5s take 1000 ms
^C

从以上的测试结果看出，在main函数使用sleep 5秒，但是打印main:sleep 5s take 1000 ms，也就是睡眠5秒，结果1秒就被打断。这是因为线程发出的SIGALRM信号被sleep函数接收了。如果想知道具体是什么终止了sleep函数，可以去看看它的实现。在测试程序中，我是把注册信号的函数放在了主线程。其实在测试的时候，我有把初始化信号函数vTimerInit放在线程vTimerProc中测试，结果也是一样的。这就可以证明结论二。而子线程vSleepProc和子线程vTimerProc中调用sleep函数并没有被终止就可以证明结论一。

  1. 结论一：默认情况下，信号将由主进程接收处理，就算信号处理函数是由子线程注册的。
  2. 结论二：对信号的处理是进程中所有的线程共享的。

接着再测试timer_create函数，注册信号是SIGUSR1。

ubuntu@ubuntu:~/test/timer_create$ ./timer_test 2
func:main ,process id is 7189
func:vPthreadInit
pthread func:vSleepProc
pthread func:vTimerProc
signal_func:1s-----> take 535963773 ms,signo=SIGUSR1(10)
main:sleep 5s take 1001 ms
signal_func:1s-----> take 1000 ms,signo=SIGUSR1(10)
main:sleep 5s take 1000 ms
signal_func:1s-----> take 1000 ms,signo=SIGUSR1(10)
main:sleep 5s take 1000 ms
signal_func:1s-----> take 999 ms,signo=SIGUSR1(10)
main:sleep 5s take 999 ms
signal_func:1s-----> take 1000 ms,signo=SIGUSR1(10)
main:sleep 5s take 1000 ms
vSleepProc:sleep 5s take 5000 ms
vTimerProc:sleep 5s take 5000 ms
signal_func:1s-----> take 1000 ms,signo=SIGUSR1(10)
main:sleep 5s take 1000 ms
signal_func:1s-----> take 1000 ms,signo=SIGUSR1(10)
main:sleep 5s take 1000 ms
signal_func:1s-----> take 1000 ms,signo=SIGUSR1(10)
main:sleep 5s take 1000 ms
^C

结果竟然和上一个结果是一样的。说明使用信号SIGUSR1还是会中断main函数的sleep函数。目前来说，我并不清楚为什么会影响到。
最后，测试不采用信号通知的方式，直接通知线程的方式：

ubuntu@ubuntu:~/test/timer_create$ ./timer_test 3
func:main ,process id is 7192
func:vPthreadInit
pthread func:vSleepProc
pthread func:vTimerProc
timer_thread:1s-----> take 535974740 ms, v.sival_int = 1111
timer_thread:1s-----> take 1000 ms, v.sival_int = 1111
timer_thread:1s-----> take 1000 ms, v.sival_int = 1111
timer_thread:1s-----> take 1000 ms, v.sival_int = 1111
main:sleep 5s take 5001 ms
timer_thread:1s-----> take 1000 ms, v.sival_int = 1111
vSleepProc:sleep 5s take 5001 ms
vTimerProc:sleep 5s take 5001 ms
timer_thread:1s-----> take 1000 ms, v.sival_int = 1111
timer_thread:1s-----> take 1000 ms, v.sival_int = 1111
timer_thread:1s-----> take 1000 ms, v.sival_int = 1111
timer_thread:1s-----> take 999 ms, v.sival_int = 1111
main:sleep 5s take 5000 ms
timer_thread:1s-----> take 1001 ms, v.sival_int = 1111
vSleepProc:sleep 5s take 5000 ms
vTimerProc:sleep 5s take 5000 ms
timer_thread:1s-----> take 999 ms, v.sival_int = 1111
timer_thread:1s-----> take 1001 ms, v.sival_int = 1111
^C

从以上结果看，使用这种方式，并没有使sleep函数终止，无论是主线程还是两个子线程，说明在应用层使用这种方式是可行的。

最后的最后，由于项目中的嵌入式linux系统中的时钟被设置为10ms，所以在应用层只能产生最高100hz的脉冲，这对步进电机来说还是有点慢，所以，没办法还是得用硬件定时中断，实现linux设备驱动。不过，对于I2C这种时钟要求不高的情况，或许可以一试。还有，提醒一点：usleep函数在应用层中是相当不精准的，select函数实现延时效果较好，但还是误差挺大的，所以才需要软件定时器。

后续

linux一些系统调用是跟信号紧密相关的，如system函数是需要捕获SIGCHLD 信号的，如果程序为了避免产生僵尸进程，而把SIGCHLD 信号设置为忽略，那system调用就会受到影响。下次再讨论system相关的技术。

云英
关注
  • 10
    点赞
  • 踩
  • 39
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
linux使用select实现精确定时器详解
01-10
在编写程序时，我们经常会用到定时器。首先看看select函数原型如下： 代码如下:int select(int nfds, fd_set *readfds, fd_set *writefds,                  fd_set *exceptfds, struct timeval *timeout);参数说明：slect的第一个参数nfds为fdset集合中最大描述符值加1，fdset是一个位数组，其大小限制为__FD_SETSIZE（1024），位数组的每一位代表其对应的描述符是否需要被检查。select的第二三四个参数表示需要关注读、写、错误事件的文件描述符位数组，这些参数既
Linux之时钟中断详解
01-20
在Linux的0号中断是一个定时器中断。在固定的时间间隔都发生一次中断，也是说每秒发生该中断的频率都是固定的。该频率是常量HZ，该值一般是在100 ~ 1000之间。该中断的作用是为了定时更新系统日期和时间，使系统时间不断地得到跳转。另外该中断的中断处理函数除了更新系统时间外，还需要更新本地CPU统计数。指的是调用scheduler_tick递减进程的时间片，若进程的时间片递减到0，进程则被调度出去而放弃CPU使用权。 时钟中断的产生 Linux的OS时钟的物理产生原因是可编程定时/计数器产生的输出脉冲，这个脉冲送入CPU，就可以引发一个中断请求信号，我们就把它叫做时钟中断。 “时钟中断”是特
6-1-1 配置定时器定时中断所需要的所有函数
最新发布
fuojbont的博客
05-26 861
此处函数共分为三部分：一、时基单元及后面的所有配置所需要的函数，5个二、时基单元之前的时钟控制相关函数，6个三、后期调试使用的函数，7个。
linux sleep函数坑你点儿没关系，但是真的坑死你
caofengtao1314的专栏
09-09 4713
linux系统编程，大家使用延时函数，最常用的是sleep，BUT。。。。。。。。。。 因为sleep（）运行是程序捕获到一个信号，那么这个信号就会中断sleep，去执行信号所指内容，等处理好信号之后，程序会直接跳到sleep的下一行执行，那么即使sleep秒数没有数完，也照样结束。这就是造成sleep失效的原因。 那么根据这个特性，我提供一种不太精确的解决方法，就是将sleep放到一个循环中去。每次循环延时1秒，因此要延时的秒数约等于循环的次数。在延时精度要求不高的情况下我认为这个方法是可行的，也希望
Sleep()函数失效的问题（WSL）
fangye945a的博客
07-06 3571
最近在指导新员工安装windows10 的Ubuntu子系统，写代码时发现其调用sleep函数无效，调用sleep直接返回，不会阻塞。 查询相关资料才知道，原来是windows10子系统 解决方法参考：https://blog.csdn.net/sinat_27953939/article/details/106473347?fps=1&locationNum=2 ...
进程线程中睡眠函数（sleep）被信号中断后失效，处理方式总结
热门推荐
qimi123456的专栏
08-16 1万+
进程线程中睡眠函数sleep被信号中断后失效，处理方式 很多时候根据程序运行需要，或者调试什么的，需要在程序中延时。当然一般应用的是sleep 函数 ， 但是有些时候，如果不注意sleep的用法，那么在多线程编程中，在信号驱使下sleep就会出现失效的特性，或者说起不到延时的作用，原因何在，先看一段代码： #include #include #include #include
Linux 实现定时器中断
qq_42475191的博客
10-09 1312
【代码】Linux 实现定时器中断。
Zynq-Linux-Timer中断源码加参考文档
06-30
这对于实现定时任务，如系统心跳检查、定时日志记录等非常有用。 6. **电源管理**： 在Zynq-Linux中，axi-timer驱动还需要考虑电源管理。在设备空闲时，可以降低定时器的工作频率或关闭它以节省能源，而在需要时...
Linux随机进程调度算法实现.doc
11-29
Linux随机进程调度算法实现 Linux 操作系统的进程调度算法是操作系统核心组件之一，负责选择系统中下一个要运行的进程。在 Linux 0.11 内核中，sched.c 函数是内核中进程调度管理的程序，其中 schedule() 函数负责...
实验四Linux中断与异常编程技术
09-23
一个是用linux内部的三个定时器，另一个是用sleep, usleep函数让进程睡眠一段时间，使用alarm定时发出一个信号，还有那就是用gettimeofday, difftime等自己来计算时间间隔，然后时间到了就执行某一任务，但是这种...
select 休眠比sleep 更准
01-26 3538
‍int mySleep(int second, int microsecond){timeval t_timeval;t_timeval.tv_sec = second;t_timeval.tv_usec = microsecond;select(0, NULL, NULL, NULL, &t_timeval);return 0;}//kfs中的有段代码是这样写的fd_set rfds;struct timeval timeout;  timeout.tv_sec = 5;  timeout.tv_use
linux下用select实现精确到睡眠时间小于1秒的sleep函数
janisonllz的博客
11-20 1227
/*精确度为0.001秒的sleep函数*/ #include #include #include #include #include #include   void sleep_1(unsigned int secs) {   struct timeval tval;   tval.tv_sec=secs/1000;
Linux编程之select
Answer的博客
09-09 1178
select系统调用的的用途是：在一段指定的时间内，监听用户感兴趣的文件描述符上可读、可写和异常等事件 为什么会出现select模型 先看一下下面的这句代码： int iResult = recv(s, buffer,1024); 这是用来接收数据的，在默认的阻塞模式下的套接字里，recv会阻塞在那里，直到套接字连接上有数据可读，把数据读到buffer里后recv函数才会返回，不然就会一直阻塞在那里。在单线程的程序里出现这种情况会导致主线程（单线程程序里只有一个默认的主线程）被阻塞,这样整个程
巧用select延时
weixin_30823001的博客
07-19 142
在LINUX用户态的情况下。假设想要延时的话。用sleep是最合适的，可是，在有些情况下，须要更小单位的延时，ms us 也是要的。用循环获取到的延时是不精确的。 幸好，select函数巧用的话，是能够做到延时的效果的。 废话不多说，直接上code： #include <stdio.h> #include <stdlib.h> #include <st...
sleep函数_C++系统之select和sleep
weixin_39616287的博客
11-28 390
最近修复内核代码，遇到一些问题，就写了点东西。我在一个进程，有三个线程，其中有两个线程需要延时自己。请问可以在这两个线程中均调用sleep函数实现延时功能吗？其中一个线程在调用sleep的时候会被另一个线程抢占吗？如果抢占了，那么计时器会不会产生冲突？另外采用select(0,NULL,NULL,NULL,&tm);实现延时的时候，可以多次这样子调用并且和sleep函数一起使用吗？sele...
select函数
goflyfreely的专栏
01-30 721
起源：现在来说，ACE我理解为socket的封装。ACE中的select函数也来源于socket。select函数的C API版本是这样的：int  select( int width,//最大句柄数加1                    fd_set   *read_fds,//监视的可读文件句柄集合。                   fd_set   *write_fd
自己整理MySQL盲注
明哥哥知识分享
08-17 920
一、基于时间延时的盲注：SLEEP 函数 SLEEP( 数字) 函数使用说明：延迟函数，为真时会延时执行代码，为假则不会执行延时。（数字为整数，例：1就是延迟一秒执行。） 例如： Select * from 表名 where id=1 and sleep(2)； 有这个id=1的内容延迟2秒执行，没有则相反。 二、配合if条件触发 IF(expr1, expr2, expr3) 如果IF(1>2, 真, 假)是true，那它的返回值就是真，如果执行条件是false，执行的条件就是假，具体情况视其所在
Linux时间类型、函数和休眠函数
luotuo44的专栏
09-18 1万+
本文主要涉及Linux时间类型、时间函数以及Linux提供的睡眠函数。   时间类型和对应的函数： time_t:       最不陌生的时间类型恐怕是time_t这个类型了吧。它出现在C语言的标准库。但ISO C中并没有规定time_t是什么类型、范围以及精度，不过在POSIX中一般是被实现为有符号的整型。        time_t的单位是秒。函数time()的返回值就是一个time
Linux定时器中断
08-15
Linux定时器中断是指在Linux系统中，使用定时器来触发一个中断事件。定时器中断可以用于很多场景，比如在系统中定时执行某个任务、实时采集数据、控制硬件设备等。 在Linux内核中，使用了两种类型的定时器：高分辨率定时器（High-Resolution Timer，HRT）和普通定时器。 高分辨率定时器是一种精度较高的定时器，它可以提供纳秒级别的精度。它的实现基于内核的基准时钟，通过周期性地触发一个中断来实现定时功能。高分辨率定时器在内核中的实现主要有三种方式：基于硬件的周期性中断、基于硬件时间戳计数器和基于软件的延迟计数。 普通定时器是一种相对较低精度的定时器，它的实现依赖于系统的节拍器（TICK）。节拍器是一个固定频率的时钟中断，它以固定的时间间隔触发中断事件。在Linux内核中，普通定时器主要用于实现延迟执行某个任务、定期执行某个函数等。 通过使用定时器中断，我们可以在Linux系统中实现各种定时任务和周期性操作，提高系统的实时性和可靠性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值