Linux下多线程实例

最新推荐文章于 2021-05-21 14:41:07 发布
最新推荐文章于 2021-05-21 14:41:07 发布
阅读量243 收藏
点赞数
分类专栏： C语言 Linux 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xianyuxiaoqiang/article/details/51121116
版权
操作系统 同时被 3 个专栏收录
6 篇文章 0 订阅
订阅专栏
C语言
5 篇文章 0 订阅
订阅专栏
Linux
3 篇文章 0 订阅
订阅专栏

mydef.h

#include <semaphore.h>
#include <errno.h>
#ifdef Solaris
#include <thread.h>
#include <synch.h>
#endif
#ifdef Linux
#include <pthread.h>
#endif
#define MY_ERROR(thread,func) \
{\
    printf("Error in thread\"%s\",func=\"%s\",errno=%d\n",thread,func,errno);\
}
#define MY_ERROR2(thread,func,rt) \
{\
    printf("Error in thread\"%s\",func=\"%s\",return=%d,errno=%d\n",thread,func,rt,errno);\
}

typedef struct param_tag{
#ifdef Linux
    sem_t *sema1_p;
    sem_t *sema2_p;
#else
    sema_t *sema1_p;
    sema_t *sema2_p;
#endif
}param_t;

extern void * t1(void * p);
extern void * t2(void * p);
extern void * t3(void * p);
extern void * t4(void * p);
extern void * t5(void * p);
extern void * myhandle(int sig);
#ifdef Linux
extern sem_t sema1;
extern sem_t sema2;
#else
extern sema_t sema1;
extern sema_t sema2;
#endif

mytest.c 

/** main thread
 *
 *       init  semaphore
 *       start thread 1
 *       start thread 2
 *       start thread 3
 *
 **/

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <string.h>
#include <signal.h>
#include "mydef.h"

#ifdef Linux
    sem_t sema1;
    sem_t sema2;
#else
    sema_t sema1;
    sema_t sema2;
#endif
/** test deadlock
 *
 *       init  semaphore
 *       start thread 1
 *       start thread 2
 *       start thread 3
 *
 **/
int test_dlock()
{
#ifdef Linux
    pthread_t threadid;
#else
    thread_t threadid;
#endif
    param_t param;
    int rc;

#ifdef Linux
    rc = sem_init(&sema1,0,1);
    rc = sem_init(&sema2,0,1);
#else
    rc = sema_init(&sema1,1,USYNC_THREAD,NULL);
    rc = sema_init(&sema2,1,USYNC_THREAD,NULL);
#endif
    if( rc != 0 ) {
        MY_ERROR("main","sem_init")
        return 0;
    }
    
    param.sema1_p = &sema1;
    param.sema2_p = &sema2;
    
#ifdef Linux
    rc = pthread_create( &threadid, NULL, t1, (void *)¶m);
    if( rc != 0 ) {
        MY_ERROR("t1","pthread_create")
        return 0;
    }
    rc = pthread_create( &threadid, NULL, t2, (void *)¶m);
    rc = pthread_create( &threadid, NULL, t3, (void *)¶m);
#else
    rc = thr_create(NULL,0,t1, (void *)¶m,THR_BOUND,&threadid);
    if( rc != 0 ) {
        MY_ERROR("t1","thr_create")
        return 0;
    }
    rc = thr_create(NULL,0,t2, (void *)¶m,THR_BOUND,&threadid);
    rc = thr_create(NULL,0,t3, (void *)¶m,THR_BOUND,&threadid);
#endif
    sleep(5);
}
/** test EINTR
 *
 *       init  semaphore
 *       start thread 4
 *       start thread 5
 *
 **/
int test_intr()
{
#ifdef Linux
    pthread_t threadid;
#else
    thread_t threadid;
#endif
    param_t param;
    int rc;

#ifdef Linux
    rc = sem_init(&sema1,0,1);
    rc = sem_init(&sema2,0,1);
#else
    rc = sema_init(&sema1,1,USYNC_THREAD,NULL);
    rc = sema_init(&sema2,1,USYNC_THREAD,NULL);
#endif
    if( rc != 0 ) {
        MY_ERROR("main","sem_init")
        return 0;
    }
    
    signal(SIGSYS,myhandle);
    
    param.sema1_p = &sema1;
    param.sema2_p = &sema2;
#ifdef Linux
    rc = pthread_create( &threadid, NULL, t4, (void *)¶m);
    if( rc != 0 ) {
        MY_ERROR("t4","pthread_create")
        return 0;
    }
    rc = pthread_create( &threadid, NULL, t5, (void *)¶m);
#else
    rc = thr_create(NULL,0,t4, (void *)¶m,THR_BOUND,&threadid);
    if( rc != 0 ) {
        MY_ERROR("t4","thr_create")
        return 0;
    }
    rc = thr_create(NULL,0,t5, (void *)¶m,THR_BOUND,&threadid);
#endif
    sleep(100);
    return 0;
}
/** test EINTR single thread
 *
 *       init  semaphore
 *       t4()
 *
 **/
int test_intr_single()
{
    param_t param;
    int rc;

#ifdef Linux
    rc = sem_init(&sema1,0,1);
#else
    rc = sema_init(&sema1,1,USYNC_THREAD,NULL);
#endif
    if( rc != 0 ) {
        MY_ERROR("main","sem_init")
        return 0;
    }
    
    param.sema1_p = &sema1;
    param.sema2_p = NULL;
    t4(¶m);
    return 0;
}
int main()
{
    test_intr_single();
}

t1.c 

/** thread 1
 *
 *       sem_wait(lock1)
 *       sleep(1)
 *       sem_wait(lock2)
 *       deadLock with t2   !!!
 *
 *
 **/
 
 
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <string.h>
#include "mydef.h"
extern void * t1(void * p)
{
#ifdef Linux
    sem_t *sema1_p;
    sem_t *sema2_p;
#else
    sema_t *sema1_p;
    sema_t *sema2_p;
#endif
    param_t *param_p = p;
    int rc;
    int val;

    sema1_p = param_p->sema1_p;
    sema2_p = param_p->sema2_p;
    
#ifdef Linux
    rc = sem_wait(sema1_p);
#else
    rc = sema_wait(sema1_p);
#endif
    if( rc != 0 ) {
        MY_ERROR("t1","sema_wait(sema1)")
        return 0;
    }
    printf("thread \"t1\" get \"sema1\" OK.\n");
#ifdef Linux
    rc = sem_getvalue(sema1_p, &val);
    printf("thread \"t1\" value of \"sema1\" is %d.\n", val);
#endif
    sleep(1);
#ifdef Linux
    rc = sem_getvalue(sema2_p, &val);
    printf("thread \"t1\" value of \"sema2\" is %d.\n", val);
#endif
    printf("thread \"t1\" waiting for \"sema2\" ...\n");
#ifdef Linux
    rc = sem_wait(sema2_p);
#else
    rc = sema_wait(sema2_p);
#endif
    if( rc != 0 ) {
        MY_ERROR("t1","sema_wait(sema2)")
        return 0;
    }
    printf("thread \"t1\" get \"sema2\" OK.\n");
    return 0;
}

t2.c 

/** thread 2
 *
 *       sem_wait(lock2)
 *       sleep(1)
 *       sem_wait(lock1)
 *       deadLock with t1  !!!
 *
 *
 **/
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <string.h>
#include "mydef.h"
extern void * t2(void * p)
{
#ifdef Linux
    sem_t *sema1_p;
    sem_t *sema2_p;
#else
    sema_t *sema1_p;
    sema_t *sema2_p;
#endif
    param_t *param_p = p;
    int rc;
    int val;

    sema1_p = param_p->sema1_p;
    sema2_p = param_p->sema2_p;
    
#ifdef Linux
    rc = sem_wait(sema2_p);
#else
    rc = sema_wait(sema2_p);
#endif
    if( rc != 0 ) {
        MY_ERROR("t2","sema_wait(sema2)")
        return 0;
    }
    printf("thread \"t2\" get \"sema2\" OK.\n");
#ifdef Linux
    rc = sem_getvalue(sema2_p, &val);
    printf("thread \"t2\" value of \"sema2\" is %d.\n", val);
#endif
    sleep(1);
#ifdef Linux
    rc = sem_getvalue(sema1_p, &val);
    printf("thread \"t2\" value of \"sema1\" is %d.\n", val);
#endif
    printf("thread \"t2\" waiting for \"sema1\" ...\n");
#ifdef Linux
    rc = sem_wait(sema1_p);
#else
    rc = sema_wait(sema1_p);
#endif
    if( rc != 0 ) {
        MY_ERROR("t2","sema_wait(sema1)")
        return 0;
    }
    printf("thread \"t2\" get \"sema1\" OK.\n");
    return 0;
}

t3.c 

/** thread 3
 *
 *       sleep(3)
 *       sem_trywait(lock1)
 *       deteck deadLock between t1 and t2
 *
 **/
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <string.h>
#include "mydef.h"
extern void * t3(void * p)
{
#ifdef Linux
    sem_t *sema1_p;
    sem_t *sema2_p;
#else
    sema_t *sema1_p;
    sema_t *sema2_p;
#endif
    param_t *param_p = p;
    int rc;
    int val;

    sema1_p = param_p->sema1_p;
    sema2_p = param_p->sema2_p;
    
    sleep(3);
    errno = -1;
#ifdef Linux
    rc = sem_trywait(sema1_p);
    if( rc == -1 ) {
        switch(errno)
        {
            case EBUSY:
                printf("thread \"t3\" can't get \"sema1\" : EBUSY.\n");
                break;
            case EAGAIN:
                printf("thread \"t3\" can't get \"sema1\" : EAGAIN.\n");
                break;
            case EDEADLK:
                printf("thread \"t3\" can't get \"sema1\" : EDEADLK.\n");
                break;
            case EINTR:
                printf("thread \"t3\" can't get \"sema1\" : EINTR.\n");
                break;
            default:
                MY_ERROR2("t3","sema_trywait(sema1)",rc)
        }
        return 0;
    }
    if( rc != 0 ) {// for solaris librt.so
        switch(rc)
        {
            case EBUSY:
                printf("thread \"t3\" can't get \"sema1\" : EBUSY.\n");
                break;
            case EAGAIN:
                printf("thread \"t3\" can't get \"sema1\" : EAGAIN.\n");
                break;
            case EDEADLK:
                printf("thread \"t3\" can't get \"sema1\" : EDEADLK.\n");
                break;
            case EINTR:
                printf("thread \"t3\" can't get \"sema1\" : EINTR.\n");
                break;
            default:
                MY_ERROR2("t3","sema_trywait(sema1)",rc)
        }
        return 0;
    }
#else
    rc = sema_trywait(sema1_p);
    if( rc != 0 ) {
        switch(rc)
        {
            case EBUSY:
                printf("thread \"t3\" can't get \"sema1\" : EBUSY.\n");
                break;
            case EAGAIN:
                printf("thread \"t3\" can't get \"sema1\" : EAGAIN.\n");
                break;
            case EDEADLK:
                printf("thread \"t3\" can't get \"sema1\" : EDEADLK.\n");
                break;
            case EINTR:
                printf("thread \"t3\" can't get \"sema1\" : EINTR.\n");
                break;
            default:
                MY_ERROR("t3","sema_trywait(sema1)")
        }
        return 0;
    }
#endif
    printf("thread \"t3\" get \"sema1\" OK.\n");
    return 0;
}

t4.c 

/** thread 4
 *
 *       loop:   usleep(100000);sem_trywait(sema1);sem_post(sema1);
 *       deteck EINTR in sem_trywait()
 *
 **/
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <string.h>
#include "mydef.h"
extern void * t4(void * p)
{
#ifdef Linux
    sem_t *sema1_p;
    sem_t *sema2_p;
#else
    sema_t *sema1_p;
    sema_t *sema2_p;
#endif
    param_t *param_p = p;
    int rc;
    int val;

    sema1_p = param_p->sema1_p;
    sema2_p = param_p->sema2_p;
    
    while(1)
    {
        usleep(100000);
        errno = -1;
#ifdef Linux
    //rc = sem_getvalue(sema1_p, &val);
    //printf("thread \"t4\" value of \"sema1\" is %d.\n", val);
        rc = sem_trywait(sema1_p);
        //rc = sem_wait(sema1_p);
        if( rc == -1 ) {
            switch(errno)
            {
                case EBUSY:
                    printf("thread \"t4\" can't get \"sema1\" : EBUSY.\n");
                    break;
                case EAGAIN:
                    printf("thread \"t4\" can't get \"sema1\" : EAGAIN.\n");
                    break;
                case EDEADLK:
                    printf("thread \"t4\" can't get \"sema1\" : EDEADLK.\n");
                    break;
                case EINTR:
                    printf("thread \"t4\" can't get \"sema1\" : EINTR.\n");
                    break;
                default:
                    MY_ERROR2("t4","sema_trywait(sema1)",rc)
            }
        }
#else
        rc = sema_trywait(sema1_p);
        if( rc != 0 ) {
            switch(rc)
            {
                case EBUSY:
                    printf("thread \"t4\" can't get \"sema1\" : EBUSY.\n");
                    break;
                case EAGAIN:
                    printf("thread \"t4\" can't get \"sema1\" : EAGAIN.\n");
                    break;
                case EDEADLK:
                    printf("thread \"t4\" can't get \"sema1\" : EDEADLK.\n");
                    break;
                case EINTR:
                    printf("thread \"t4\" can't get \"sema1\" : EINTR.\n");
                    break;
                default:
                    MY_ERROR("t4","sema_trywait(sema1)")
            }
        }
#endif
#ifdef Linux
        rc = sem_post(sema1_p);
        if( rc == -1 ) {
            switch(errno)
            {
                case EBUSY:
                    printf("thread \"t4\" can't post \"sema1\" : EBUSY.\n");
                    break;
                case EAGAIN:
                    printf("thread \"t4\" can't post \"sema1\" : EAGAIN.\n");
                    break;
                case EDEADLK:
                    printf("thread \"t4\" can't post \"sema1\" : EDEADLK.\n");
                    break;
                case EINTR:
                    printf("thread \"t4\" can't post \"sema1\" : EINTR.\n");
                    break;
                default:
                    MY_ERROR2("t4","sem_post(sema1)",rc)
            }
        }
#else
        rc = sema_post(sema1_p);
        if( rc != 0 ) {
            switch(rc)
            {
                case EBUSY:
                    printf("thread \"t4\" can't post \"sema1\" : EBUSY.\n");
                    break;
                case EAGAIN:
                    printf("thread \"t4\" can't post \"sema1\" : EAGAIN.\n");
                    break;
                case EDEADLK:
                    printf("thread \"t4\" can't post \"sema1\" : EDEADLK.\n");
                    break;
                case EINTR:
                    printf("thread \"t4\" can't post \"sema1\" : EINTR.\n");
                    break;
                default:
                    MY_ERROR("t4","sema_post(sema1)")
            }
        }
#endif
    }
    return 0;
}

t5.c 

/** thread 5
 *
 *       loop:   usleep(50000);raise(signum);
 *
 *       try EINTR in sem_trywait()
 *
 **/
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <string.h>
#include <signal.h>
#include "mydef.h"
extern void * t5(void * p)
{
    while(1)
    {
        usleep(50000);
        raise(SIGSYS);
    }
    return 0;
}

extern void * myhandle(int sig)
{
    return 0;
}

cmp_linux.sh 

#!/bin/sh
cc -c  -DLinux t1.c
cc -c  -DLinux t2.c
cc -c  -DLinux t3.c
cc -c  -DLinux t4.c
cc -c  -DLinux t5.c
cc -c  -DLinux mytest.c
cc -o mytest t1.o t2.o t3.o t4.o t5.o mytest.o -lpthread

cmp_sol.sh 

#!/bin/sh
cc -c  -DSolaris t1.c
cc -c  -DSolaris t2.c
cc -c  -DSolaris t3.c
cc -c  -DSolaris t4.c
cc -c  -DSolaris t5.c
cc -c  -DSolaris mytest.c
cc -o mytest t1.o t2.o t3.o t4.o t5.o mytest.o -lpthread


xianyuxiaoqiang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux下使用librt中的定时器
Gothic的专栏
10-12 7624
librt是Posix的实时扩展库，下面是他内部关于定时器的接口：timer_createtimer_deletetimer_getoverruntimer_gettimetimer_settime下面是例子：#include iostream>using namespace std;#include pthread.h>#include unistd.h>#include stdlib.
linux多线程例子
paomadi的专栏
01-24 1698
一.基本功能 1.最简单例子--创建线程 /* * * 创建线程 * */ #include #include #include void *thread1(void *arg) { printf("this thread1!\n"); } int main(int argc,char **argv) { int ret; pthread_t
Linux多线程编程(一)---多线程基本编程
热门推荐
王文松的博客
07-20 2万+
线程是指运行中的程序的调度单位。一个线程指的是进程中一个单一顺序的控制流，也被称为轻量级线程。它是系统独立调度和分配的基本单位。同一进程中的多个线程将共享该系统中的全部系统资源，比如文件描述符和信号处理等。一个进程可以有很多线程，每个线程并行执行不同的任务。
linux中线程例子,Linux多线程编程(3)——实例分析
weixin_35422396的博客
05-06 233
1、背景说明：MJPG-streamer是一个开源软件，它可从一个输入插件复制JPG帧到多个输出插件。它的输入插件从摄像头、文件系统或其它输入插件读取视频数据，并复制到内存中，它有多个输出插件将这些视频数据经过处理，其中最重要的输出插件是网站服务器插件，它将视频帧以M-JPEG流的形式通过基于ip的网络传输到浏览器如Firefox，Cambozola，VLC播放器，Windows的移动设备或者其他...
Linux 内核同步（五）：信号量（semaphore）
StephenZhou
01-24 1万+
信号量 Linux Kernel 除了提供了自旋锁，还提供了睡眠锁，信号量就是一种睡眠锁。信号量的特点是，如果一个任务试图获取一个已经被占用的信号量，他会被推入等待队列，让其进入睡眠。此刻处理器重获自由，去执行其他的代码。当持有的信号量被释放，处于等待队列的任务将被唤醒，并获取到该信号量。 从信号量的睡眠特性得出一些结论： 由于竞争信号量的时候，未能拿到信号的进程会进入睡眠，所以信号量可以适...
[Linux]多线程同步之sem_wait()学习笔记
modi000的博客
05-21 1131
转载：https://blog.csdn.net/tzshlyt/article/details/53150697 1、semaphore 的这种信号量不仅可用于同一进程的线程同步，也可以用于不同进程间同步。 一个生产者-消费者例子：生产者不停的向一个固定大小的环形队列中添加数据，消费者从环形队列中清零数据，如果生产者积累的数据大于环形队列长度，则等待消费者清除数据有空位后再生产。 #include <stdlib.h> #include <pthread.h> #incl.
Linux下多线程编程实例解析
GQ1900的博客
04-07 5317
提到线程，不得不让人想起进程，所以还是先写下进程与线程的区别吧！ 一、进程与线程的区别 进程是程序执行的一个实例，进程有其自己独立的地址空间。一个线程可以含有多个线程，这也是为了提高系统资源利用率，线程的引入有其必然的优势，线程有自己的堆栈。记得操作系统的书籍上有一句经典的话”进程——资源分配的最小单位，线程——程序执行的最小单位“。一个通俗的比喻：进程就像一个人，而线程就好像人体内协
Linux下的多线程编程实例解析
09-14
【Linux下的多线程编程实例解析】 在计算机操作系统中，多线程编程是实现并行处理和提高系统效率的一种重要技术。Linux系统同样支持多线程编程，这使得开发者能够利用这一特性创建高效的、响应迅速的应用程序。多...
linux epoll多线程编程 例子
01-19
总结来说，Linux的epoll多线程编程能够有效地提升高并发场景下的系统性能，通过结合线程池，可以更好地管理和调度资源，降低系统开销。正确理解和运用这些技术，对于开发高效、稳定的服务器程序至关重要。
Linux中多线程详解及简单实例
01-20
Linux中多线程详解及简单实例 1.概念 进程：运行中的程序。 线程：一个程序中的多个执行路径。更准确的定义是：线程是一个进程内部的一个控制序列。 2.为什么要有线程？ 用fork调用进程代价太高，需要让一个...
linux下的C\C++多进程多线程编程实例详解
01-20
linux下的C\C++多进程多线程编程实例详解 1、多进程编程 #include #include #include <unistd> int main() { pid_t child_pid; /* 创建一个子进程 */ child_pid = fork(); if(child_pid == 0) { printf...
c++多线程
aocenmin8777的博客
08-02 460
C++ 多线程 多线程是多任务处理的一种特殊形式，多任务处理允许让电脑同时运行两个或两个以上的程序。一般情况下，两种类型的多任务处理：基于进程和基于线程。 基于进程的多任务处理是程序的并发执行。 基于线程的多任务处理是同一程序的片段的并发执行。 多线程程序包含可以同时运行的两个或多个部分。这样的程序中的每个部分称为一个线程，每个线程定义了一个单独的执行路径。 本...
Linux多线程编程实例解析
知秋一叶
12-14 2万+
Linux系统下的多线程遵循POSIX线程接口，称为 pthread。编写Linux下的多线程程序，需要使用头文件pthread.h，连接时需要使用库libpthread.a。顺便说一下，Linux 下pthread的实现是通过系统调用clone（）来实现的。clone（）是 Linux所特有的系统调用，它的使用方式类似fork，关于clone（）的详细情况，有兴趣的读者可以去查看有关文档说明。下
linux并发控制之信号量
williamwang2013的专栏
01-21 3273
信号量(semaphore)是用于保护临界区的一种常用方法,它的使用方式与自旋锁类似 与自旋锁相同的是,只有得到信号量的进程才能执行临界区的代码 与自旋锁不同的是,当获取不到信号量的时候,进程不会在原地打转,而是进入休眠等待状态; 理解： 定义于#include struct semaphore { spinlock_tlock; unsigned intcoun
Shell脚本实现文件的互斥访问
xianyuxiaoqiang的专栏
04-12 2285
1.前言 Shell中似乎不存在通用的文件互斥访问机制。Linux下有flock命令，但Solaris没有。 通过一番调查，笔者找到了一个简单易行的方法来弥补Shell的这一不足。   2.原理 原理比较简单。主要是以下两个命令的配合使用： 命令A： set -o noclobber 命令B： echo XXX > filename
简单的Win Socket实例(回环通信)
xianyuxiaoqiang的专栏
12-05 1349
/** cl testSock.c wsock32.lib odbc32.lib odbccp32.libmpr.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbcc
Linux文件权限浅析
xianyuxiaoqiang的专栏
02-06 731
1.       前言 Linux系统中，文件权限有三大类：文件所属用户权限、文件所属组权限、其他用户权限。对于每一类，又有3种具体权限：读权限、写权限、执行权限(对于文件夹，是打开权)。  使用”ll”命令，可以看到一个文件前面有如下的信息： 上图中，用彩色标注的9个字节就是本文将要分析的文件权限符号。其他部分本文暂不讨论。 ※ “文件所属组”不含“文件所属用户”。“其他用户”是指除
Linux虚拟机开启共享文件夹
xianyuxiaoqiang的专栏
02-09 666
1.备份samba配置文件#cd /etc/samba #cp smb.conf smb.conf.bak #vi smb.conf 2.在smb.conf中输入如下信息      [public]      comment = common dir      path = /share      public = yes      writable = yes      p
Solaris性能测试工具collect的用法
xianyuxiaoqiang的专栏
12-05 536
collect  -p hi -F all  ……

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值