Linux的多线程（线程的创建，退出，取消请求，取消处理例程，线程属性的设置）

最新推荐文章于 2024-11-06 09:27:30 发布
最新推荐文章于 2024-11-06 09:27:30 发布
阅读量804 收藏 9
点赞数 17
文章标签： linux c语言 运维 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64547558/article/details/142664086
版权

进程:是系统分配资源的最小单位,系统会为每一个进程分配一块独立的虚拟内存空间

线程:是系统调度的最小单位,系统不会为线程分配新的内存空间,但是线程也参与系统调度

cpu把时间片分给每一个进程，进程中的时间片再切分分给每一个线程，所以线程也会得到时间片，所以线程使系统调度的最小单位

线程的创建

#include <pthread.h>

int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
                                  void *(*start_routine) (void *), void *arg);

pthread_t *thread      //线程的tid
const pthread_attr_t *attr    //线程的属性
void *(*start_routine) (void *)    //线程的任务函数
void *arg    //传递给任务函数的参数

编译时的时候记得添加  -lpthread

 void *(*start_routine) (void *) 函数指针,指向需要执行的任务函数 
 任务函数返回值必须为  void *, 参数必须为 void *，回调函数

#include <stdio.h>
#include <pthread.h>

// 任务线程
void *task1(void *arg)
{
    int j = 0;
    while (1)
    {
        printf("j=%d\n", j++);
    }
}

// 任务线程
void *task2(void *arg)
{
    int i = 0;
    while (1)
    {
        printf("i=%d\n", i++);
    }
}

// 任务线程
void *task3(void *arg)
{
    int k = 0;
    while (1)
    {
        printf("k=%d\n", k++);
    }
}

int main()
{
    pthread_t tid1;
    pthread_create(&tid1, NULL, task1, NULL);

    pthread_t tid2;
    pthread_create(&tid2, NULL, task2, NULL);

    pthread_t tid3;
    pthread_create(&tid3, NULL, task3, NULL);

    getchar();  //调用一个阻塞函数不让进程结束
}

 线程传递参数

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>

struct arg
{
    int a;
    double b;
    char str[1024];
} ;

// 线程任务函数
void *task(void *arg)
{
    struct arg *p = arg;
 
    printf("整数1 %d\n", p->a);
    printf("浮点1 %f\n", p->b);
    printf("字符1 %s\n", p->str);

}

int main()
{
    struct arg arg = {15678, 156.78, "15678"};
    // 创建一个线程
    pthread_t tid;
    pthread_create(&tid, NULL, task, &arg);  //&arg是线程函数中的参数

    sleep(1);
    printf("整数2 %d\n", arg.a);
    printf("浮点2 %f\n", arg.b);
    printf("字符2 %s\n", arg.str);

    getchar(); //阻塞主进程
}

线程退出

退出当前线程

#include <pthread.h>
void pthread_exit(void *retval);

参数retval是线程的返回值，对应线程执行函数的返回值。若线程没有数据可返回则可写成NULL。

pthread_exit()用法可参照exit()

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

void *task(void *arg) // 子线程
{
    int i = 0;
    while (1)
    {
        printf("i=%d\n", i++);
        sleep(1);
        if (i == 10)
        {
            printf("退出子线程\n");
            pthread_exit(NULL); // 退出子线程
        }
    }
}

int main() // main 主线程
{
    // 创建线程线程
    pthread_t tid;
    pthread_create(&tid, NULL, task, NULL);

    // 默认情况，主函数结束，那么进程也会结束，所有线程都会死亡！

    printf("退出主线程\n");
    pthread_exit(NULL); // 退出  main主函数线程。只是结束线程，进程并未结束
                        // 所以就算主线程结束了子线程也还是会继续运行
}

回收一个线程资源，主线程阻塞等待子线程结束，然后回收子线程资源

#include <pthread.h>
int pthread_join(pthread_t thread, void **retval)

thread: 需要回收资源的线程tid
retval：线程的退出参数，参数同上填NULL即可

通过阻塞等待线程执行完回收资源 

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>


// 任务线程
void *task(void *arg)
{
    int i = 0; // 局部变量，属于线程的栈空间
    while (1)
    {
        printf("线程正在执行任务 &i=%p %d\n", &i, i++);

        if (i == 10)
        {
            pthread_exit(&i); // 退出线程
        }
        sleep(1);
    }
}

int main()
{
    // 1.创建一个线程
    pthread_t tid;
    pthread_create(&tid, NULL, task, NULL);

    printf("等待线程结束回收资源\n");

    void *p = NULL;
    pthread_join(tid, &p); // 一直阻塞等待线程退出 ！ 回收线程的栈空间

    printf("线程结束 退出参数:%p\n", p);
    printf("退出参数 %d\n", *((int *)p)); // 访问已经回收后的内存资源，非法访问！！

    exit(0);

}

如果没有pthread_join那么线程根本不会执行完，直接在主线程中就exit(0)退出进程了


线程取消

发送一个取消命令给线程

#include <pthread.h>
int pthread_cancel(pthread_t thread);

thread:需要取消的线程 tid
成功返回 0，失败将返回错误码

pthread_self()   返回主线程的线程号tid

线程取消请求

        当线程收到一个取消请求时,他将会如何表现取决于两个东西:一是当前的取消状态,二是当前的取消类型。

        线程的取消状态很简单--分别是PTHREADCANCEL ENABLE和 PTHREAD CANCEL DISABLE，前者是缺省的，代表线程可以接受取消请求，后者代表关闭取消请求，不对其响应。

        而在线程接受取消请求的情况下,如何停下来又取决于两种不同的响应取消请求的策略一延时响应和立即响应,当采取延时策略时,线程并不会立即退出,而是要遇到所谓的“取消点”之后，才退出。而“取消点”，指的是一系列指定的函数。

#include <pthread.h>
int pthread_setcancelstate(int state, int *oldstate);//开启或关闭取消请求

state : 新的取消状态              PTHREAD_CANCEL_ENABLE 开启
                                               PTHREAD_CANCEL_DISABLE 关闭
oldstate:原来的状态

int pthread_setcanceltype(int type, int *oldtype); //设置取消类型

type:取消类型                                    PTHREAD_CANCEL_DEFERRED 延时取消 （默认类型）
                                                          PTHREAD_CANCEL_ASYNCHRONOUS 立即取消

返回值：成功 0

               失败errno
 

设置线程取消请求demo：

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
// 任务线程
void *task(void *arg)
{
    // 关闭取消请求
    pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
    int i = 0;
    while (1)
    {
        printf("线程正在执行任务 %d\n", i++);
        if (i == 10)
        {
            printf("执行完毕\n");
            break;
        }
        sleep(1);
    }
    // 开启取消请求
    pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);

    while (1)
    {
        printf("线程正在运行\n");
        sleep(1);
    }
}

int main()
{
    // 1.创建一个线程
    pthread_t tid;
    pthread_create(&tid, NULL, task, NULL);

    while (1)
    {
        printf("输入任意键取消线程\n");
        getchar();
        pthread_cancel(tid);
    }
}

 在关闭线程取消请求之后，线程无法被取消，只有在重新打开线程取消请求之后的第二个循环中才能通过pthraed_cancel取消线程

线程取消处理函数

        由于线程任何时刻都有可能持有诸如互斥锁、信号量等资源，一旦被取消很有可能导致别的线程出现死锁，因此如果一条线程的确可能被取消，那么在被取消之前必须使用以下API来为将来可能出现的取消请求注册“处理例程”，让这些例程自动释放持有的资源。

注册一个取消处理函数，当线程被取消时，会去执行该函数

#include <pthread.h>
void pthread_cleanup_push(void (*routine)(void *), void *arg);

routine: 函数指针，指向线程被取消后需要执行的函数
arg:传递给取消处理函数使用的参数

void pthread_cleanup_pop(int execute);

execute: 0 不执行,线程正常结束不执行取消处理函数 
               1 执行,线程正确结束执行取消处理函数（只要线程被取消，都会执行取消处理函数）

pthread_cleanup_push必须与 pthread_cleanup_pop 一起使用,且在同一个作用域中

注册一个线程取消处理函数demo：

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
FILE *fp = NULL;

void clear_task(void *arg)
{
    printf("线程被取消，执行取消处理函数\n");
    fclose(fp); // 关闭文件，刷新缓存
}

void *task(void *arg)
{
    int i = 0;
    // 打开文件
    fp = fopen("test.txt", "w+");

    // 注册一个取消处理函数
    pthread_cleanup_push(clear_task, NULL);

    while (1) // 正在运行的时候被别人取消了
    {
        fputc('Q', fp); // 写入文件
        printf("线程正在写入数据到文件中\n");
        sleep(1);
        i++;
        if (i == 10)
        {
            break;
        }
    }

    //pthread_cleanup_pop(0); // 正常结束的时候,不执行
    pthread_cleanup_pop(1); //正常结束的时候, 执行

    printf("线程正常结束\n");
    fclose(fp); // 关闭文件，刷新缓存
}

int main()
{
    // 1.创建一个线程
    pthread_t tid;
    pthread_create(&tid, NULL, task, NULL);

    while (1)
    {
        printf("按任意键取消线程\n");
        getchar();
        pthread_cancel(tid);
    }

    return 0;
}

 在这段代码中当pthread_cleanup_pop中的值为1时，线程正常结束时也会执行clean_task中的函数，如果excute的值为0的话，那么只有在线程执行的过程中被打断会执行clean_task函数。

线程属性的设置

线程相关的api

 

 

查看系统的资源

loading@DESKTOP-R0NLPTR:~$ ulimit -a
real-time non-blocking time  (microseconds, -R) unlimited
core file size              (blocks, -c) 0              #core文件的最大值为100 blocks。
data seg size               (kbytes, -d) unlimited    #进程的数据段可以任意大。
scheduling priority                 (-e) 0        #调度优先级
file size                   (blocks, -f) unlimited     #文件可以任意大。
pending signals                     (-i) 25348       #最多有25348个待处理的信号。
max locked memory           (kbytes, -l) 64          #一个任务锁住的物理内存的最大值为32KB。
max memory size             (kbytes, -m) unlimited    #一个任务的常驻物理内存的最大值。
open files                          (-n) 1024        #一个任务最多可以同时打开1024的文件。
pipe size                (512 bytes, -p) 8        #管道的最大空间为4096字节。
POSIX message queues         (bytes, -q) 819200     #POSIX的消息队列的最大值为819200字节。
real-time priority                  (-r) 0
stack size                  (kbytes, -s) 8192        #进程的栈的最大值为10240字节。
cpu time                   (seconds, -t) unlimited    #进程使用的CPU时间。
max user processes                  (-u) 25348    #当前用户同时打开的进程（包括线程）的最大个数为25348。
virtual memory              (kbytes, -v) unlimited    #没有限制进程的最大地址空间。
file locks                          (-x) unlimited    #所能锁住的文件的最大个数没有限制。

设置线程属性的流程

1、初始化线程属性

2、设置线程属性

3、根据设置的线程属性创建线程

4、销毁线程和属性

线程属性也是线程创建的第二个参数

线程属性的创建和销毁

#include <pthread.h>

int pthread_attr_init(pthread_attr_t *attr);
int pthread_attr_destroy(pthread_attr_t *attr);
       

线程属性的设置

#include <pthread.h>

int pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize); //设置栈大小 
int pthread_attr_getstacksize(const pthread_attr_t *attr,
                                                   size_t *stacksize);//获取栈大小

线程栈空间的设置
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

void *task(void *arg)
{
    int i = 0;
    while (1)
    {
        printf("线程正在运行 %d\n", i++);
        sleep(1);

        if (i == 10)
        {
            // 退出线程
            pthread_exit(NULL);
        }
    }
}

int main()
{
    // 初始化一个线程属性
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    int n;
    printf("请输入需要设置的线程大小\n");
    scanf("%d", &n);
    // 设置线程属性

    //分配的栈空间必须比系统分配最小的栈空间要大，
    //本机最小栈空间为16384，下文给出查看最小分配栈空间办法
    int size = 16384 + n;
    // int size = 1024;
    pthread_attr_setstacksize(&attr, size);

    // 根据当前的栈大小创建线程
    pthread_t tid;
    pthread_create(&tid, &attr, task, NULL);

    // 获取当前线程的栈大小
    size_t stacksize = 0;
    pthread_attr_getstacksize(&attr, &stacksize); // 获取栈大小

    printf("当前线程的栈大小 %ld\n", stacksize);

    // 回收线程资源
    pthread_join(tid, NULL);

    // 销毁属性
    pthread_attr_destroy(&attr);
}

获取本机当前需要分配的最小栈空间

stack_min.c

#include <stdio.h>
#include <limits.h>

int main()
{
    printf("%d\n", PTHREAD_STACK_MIN);
}

可以看到本机的栈空间为16384

loading@DESKTOP-R0NLPTR:~/ gcc stack_min.c && ./a.out
16384
 线程分离属性设置

        一条线程如果是可接合的，意味着这条线程在退出时不会自动释放自身资源，而会成为僵尸线程，同时意味着该线程的退出值可以被其他线程获取。

        因此，如果不需要某条线程的退出值的话，那么最好将线程设置为分离状态，以保证该线程不会成为僵尸线程。

#include <pthread.h> 

int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate); 
int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate); 

detachstate： 线程分离属性           PTHREAD_CREATE_DETACHED 分离状态，自动回收资源 
                                                        PTHREAD_CREATE_JOINABLE   结合状态，手动回收资源 

注意:当一个线程设置为分离属性后，pthread_join 函数失效了！ 因为该线程已经无需手动回收资源！没有返回值的函数是宏定义函数！

设置分离属性自动回收资源demo：

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

void *task(void *arg)
{
    int i = 0;
    while (1)
    {
        printf("线程正在运行 %d\n", i++);
        sleep(1);

        if (i == 10)
        {
            // 退出线程
            pthread_exit(NULL);
        }
    }
}

int main()
{
    // 初始化一个线程属性
    pthread_attr_t attr;
    pthread_attr_init(&attr);

    // 设置线程分离属性
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);

    // 根据当前的栈大小创建线程
    pthread_t tid;
    pthread_create(&tid, &attr, task, NULL);

    printf("等待线程结束\n");
    // 回收线程资源
    pthread_join(tid, NULL); // 失效,因为线程自己回收资源！
    printf("线程资源回收\n");

    // 销毁属性
    pthread_attr_destroy(&attr);
    
    getchar();

}

主线程与子线程自动分离，子线程结束后，资源自动回收

#include <pthread.h>

int pthread_detach(pthread_t thread)

pthread_join()函数的替代函数，可回收创建时detachstate属性设置为PTHREAD_CREATE_JOINABLE的线程的存储空间。该函数不会阻塞父线程。pthread_join()函数用于只是应用程序在线程tid终止时回收其存储空间。如果tid尚未终止，pthread_detach()不会终止该线程

快速回收资源demo：

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

void *task(void *arg)
{
    int i = 0;
    while (1)
    {
        printf("线程正在运行 %d\n", i++);
        sleep(1);

        if (i == 10)
        {
            // 退出线程
            pthread_exit(NULL);
        }
    }
}

int main()
{
    // 根据当前的栈大小创建线程
    pthread_t tid;
    pthread_create(&tid, NULL, task, NULL);

    // 快速设置分离属性
    pthread_detach(tid);
    printf("等待线程结束\n");

    // 回收线程资源
    pthread_join(tid, NULL); // 失效,因为线程自己回收资源！
    printf("线程资源回收\n");
    getchar();
}

 

Linux 多线程原理深剖
qq_61500888的博客
12-24 4万+
带你一命通关 Linux 多线程原理 三十分钟手撕底层内涵
linux多线程间使用共享内存例程，C++版本。
12-13
linux多线程间使用共享内存例程，C++版本。可用于大量数据的多线程共享。
Linux系统编程（五）多线程创建与退出
qq_1033275663的博客
05-29 1486
由于一个进程中的多个线程是共享数据段的，因此通常在线程退出之后，退出线程所占用的资源并不会随着线程的终止而得到释放。这个函数是一个线程阻塞函数，调用这函数的线程将一直等待直到被等待的线程结束为止，当函数返回时，被等待线程的资源被回收。：在使用线程函数时，不能随意使用 exit 退出函数进行出错处理，由于 exit 的作用是使调用进程终止，往往一个进程包括了多个线程，所以在线程中通常使用 pthread_exit 函数来代替进程中的退出函数 exit。一般线程的退出和线程的等待是一起使用的。
Linux多线程并发运行原理+代码例程详解
“逛丢一只鞋”的博客
04-02 2159
交叉编译 #include <stdio.h> #include <pthread.h> #include <stdlib.h> /*thread1*/ void thread1(void) { int i = 0; for(i = 0; i < 6; i++) { printf("This is a pthread1. \n"); if(i == 2){ pthread_exit(0);.
Linux 多线程开发（附有案例代码）
热爱数据库的小胖
07-15 5800
同一个程序中的所有线程均会独立执行相同程序，且共享同一份全局内存区域，其中包括初始化数据段、未初始化数据段，以及堆内存段。(传统意义上的UNIX进程只是多线程程序的一个特例,该进程只包含一个线程)调用fork()来创建进程的代价相对较高，即便利用写时复制技术，仍热需要复制诸如内存页表和文件描述符表之类的多种进程属性，这意味着fork()调用在时间上的开销依然不菲。进程间的信息难以共享。由于除去只读代码段外，父子进程并未共享内存，因此必须采用一些进程间通信方式，在进程间进行信息交换。进程ID和父进程工D。..
易语言多线程的运用例程
07-23
易语言提供了创建和管理多线程的能力。下面我们将逐一解释这个例程中的关键概念： 1. **开始**：这通常是指启动一个新线程。在易语言中，创建线程可以通过调用特定的系统函数，比如`创建线程`，并将需要执行的代码...
对话框多线程例程,可以控制开始和停止
09-13
在IT领域，多线程是程序设计中的一个重要概念，尤其在UI（用户界面）与后台处理相结合的应用中，它的作用尤为显著。标题提到的“对话框多线程例程”通常指的是在一个对话框应用程序中，利用多线程技术来实现对话框的...
易语言多线程许可证基本例程
07-23
在“易语言多线程许可证基本例程”这个主题中，我们将深入探讨如何在易语言中实现多线程技术，并结合许可证管理，构建一个基础的多线程许可证系统。 首先，我们要理解多线程的概念。在计算机程序中，线程是执行流程...
linux 线程 基础例程
07-23
通过这个基础例程，学习者可以了解Linux线程的基本操作，并逐步深入到多线程编程的复杂场景，如死锁预防、资源管理等。实际应用中，理解线程同步和通信的重要性，能够有效地避免竞态条件，提高程序的稳定性和效率。
c#多线程典型例程.rar
04-04
以上只是C#多线程编程的一部分知识，实际的"**c#多线程典型例程**"可能涵盖了更丰富的应用场景，如UI更新、网络请求、IO操作等。通过学习和实践这些例程，开发者可以深入理解多线程编程，提升程序的性能和用户体验。
【Linux】进程状态相关知识详细梳理
fulufulucode的博客
11-03 709
可以看到，子进程退出后，父进程没有进行资源回收（调用wait()）,子进程的状态就会变成“Z+”，其中Z表示僵尸状态 ，+表示进程属于前台进程的一部分。每个僵尸进程在进程表中保留一个条目，系统的进程表是有限的。如果僵尸进程数量过多，可能会导致进程表满，新的进程无法创建。fork函数“有两个返回值”，父进程会返回子进程的pid，子进程会返回0，于此同时，子进程会继承父进程的代码以及数据（所有运行在系统里的进程都以task_struct链表的形式存在内核里，也可以称为进程表。那么如果父进程先退出呢？
Linux初阶——线程（Part3）：POSIX 信号量 & CP 模型变体
m0_73093743的博客
11-02 487
只能建立一个对象的设计模式。
[linux 驱动]PWM子系统详解
weixin_49406449的博客
11-04 843
搜索“rockchip,rk3328-pwm”，发现在./drivers/pwm/pwm-rockchip.c 出现，所以 pwm6 的驱动是pwm-rockchip。任何 PWM 设备实例都可以被注册到 pwm_class 下，用户空间应用可以通过 /sys/class/pwm 访问这些设备，实现对 PWM 功能的控制。struct pwm_device *pwm: 这是指向 PWM 设备结构体的指针，该结构体是在调用 pwm_request 函数时获取的。这是指向该控制器的 PWM 通道的数组或链表。
Linux kernel 源码下载与源码在线阅读地址及其相关资源网站
最新发布
代码背包客的博客
11-06 254
Linux内核源码的下载地址和在线阅读方式有多种，下面是一些与之相关的网址。同时也包含一些与kernel相关的一些资源网站，供大家参考学习！
Linux——Linux基础指令
辰多代码的博客
11-05 723
比 more 更强大的分页器，支持前后翻页和搜索。1：移动文件或目录（前提是目标文件或目录不存在）。：重命名文件或目录（前提是目标文件或目录存在）。:：显示系统上当前登录的用户及其相关信息。：显示网络连接、路由表和网络接口统计信息。：统计文件的行数、字数和字节数。：显示当前工作目录的完整路径。：列出目录中的文件和子目录。：显示或设置系统日期和时间。：在目录层次结构中搜索文件。：显示系统中正在运行的进程。：配置或显示网络接口信息。：显示当前用户的用户名。：更新现有文件的时间戳。：查找可执行文件的位置。
Linux 之 信号概念、进程、进程间通信、线程、线程同步
挥剑决浮云的博客
11-01 708
如果释放互斥锁时有一个以上的线程阻塞，那么这些阻塞的线程会被唤醒，它们都会尝试对互斥锁进行加锁，当有一个线程成功对互斥锁上锁之后，其它线程就不能再次上锁了，只能再次陷入阻塞，等待下一次解锁。事实上，子进程是父进程的一个副本，譬如子进程拷贝了父进程的数据段、堆、栈以及继承了父进程打开的文件描述符，父进程与子进程并不共享这些存储空间，这是子进程对父进程相应部分存储空间的完全复制，执行fork()之后，每个进程均可修改各自的栈数据以及堆段中的变量，而并不影响另一个进程。是一族函数，而不是一个单独的函数。
Linux 基础IO
Emilia_is_angel的博客
11-02 836
对Linux的文件系统和IO接口进行了简单的介绍
Linux云计算 |【第五阶段】CLOUD-DAY7
小安的运维专栏
11-01 1366
在kubernetes平台上理解掌握各种控制器的用法：掌握kubectl管理命令、掌握POD原理、掌握集群调度的规则、熟悉控制器资源文件
Linux - grep的正则用法
limts的博客
11-03 178
利用中括号[]搜寻集合字符。
《Linux系统编程篇》管道（Linux 进程间通信（IPC））——基础篇
Strange_Head的博客
11-01 984
在 Linux 中，进程是相互独立的，每个进程都有独立的内存空间。为了在不同进程之间交换数据，操作系统提供了各种 IPC 机制。这些机制可帮助进程完成数据共享、同步、通知和事件处理等任务。管道（Pipe）命名管道（FIFO）消息队列（Message Queue）共享内存（Shared Memory）信号（Signal）套接字（Socket）管道是最简单的 IPC 方式之一，适合在具有亲缘关系的进程（如父子进程）之间传递数据。管道是单向的，数据只能从一端流向另一端。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值