Linux函数簇及线程详解

于 2022-07-25 21:53:04 发布
阅读量280 收藏 1
点赞数
分类专栏： 进线程 文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72647108/article/details/125983975
版权

exec函数簇：

1.概念:
    函数族提供了一种在进程中启动另一个程序执行的方法。
    它可以根据指定的文件名或目录名找到可执行文件，并用它来取代原调用进程的数据段、代码段和堆栈段，在执行完之后，原调用进程的内容除了进程号外，其他全部被新程序的内容替换了。另外，这里的可执行文件既可以是二进制文件，也可以是Linux下任何可执行脚本文件。
    比如bash用到了exec函数来执行我们的可执行文件。
2.在Linux中使用exec函数族主要有以下两种情况
    当进程认为自己不能再为系统和用户做出任何贡献时，就可以调用任何exec函数族让自己重生。
    如果一个进程想执行另一个程序，那么它就可以调用fork函数新建一个进程，然后调用任何一个exec函数使子进程重生。
    一般使用第二种
3.函数 
#include <unistd.h>
int exec1(const char *path,const char *arg，...);
int execv(const char *path,char *const argv[]);
int execlp(const char *file,const char *arg，...);
int execvp(const char *fi1e,char *const argv[]);
int execle(const char *path,const char *arg,...,char *const envp[]);
int execve(const char *path,char *const argv[],char *const envp[]);
返回值:
    成功不返回
    失败返回-1 更新 errno
注意:
    exec函数的参数表传递方式以函数名的第五位字母来区分:
    字母为"l"(list)的表示逐个列举的方式;
    字母为"v" (vertor)的表示将所有参数构造成指针数组传递;
    以p结尾的函数可以只给出文件名
    事实上，这6个函数中真正的系统调用只有execve，其他5个都是库函数，它们最终都会调用execve这个系统调用
例： 
//在屏幕上持续打印时间time.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>

int main(int argc, const char *argv[])
{
    while(1)
    {
        time_t t;
        time(&t);
        char *p = ctime(&t);
        printf("%s\n", p);
        sleep(1);
    }
    return 0;
}

gcc time.c -o test

//exec函数族示例代码
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
int main(int argc,int *argv[]){
    printf ( "111111111\n");
    
    //char *arg[] = {"test" ,NULL};
    //int ret = execv("./test", arg);
    
    //int ret = execl("./test","test",NULL);
    
    //int ret = execlp = ("ls","ls","-l",NULL);
    
    //char *arg[] = {"ls","-l",NULL};
    //int ret = execvp("ls", arg);

    //char *envp[] = {"PATH = .",NULL}; 设置当前环境变量
    //int execle("./test","test",NULL,envp);

        //char *arg[] = {"test",NULL};
        //char *envp[] = {"PATH = .",NULL}; 设置当前环境变量
    //int execve("./test",arg,envp);
    
    if(ret == -1){
        perror ("execl") ;
        exit(-1);
    }
    printf("222222222\n");
    return 0;
}

守护进程：

1.守护进程:
        在linux中与用户交互的界面叫终端，从终端运行起来的程序都依附于这个终端，当终端关关闭时，相应的进程都会被关闭，守护进程可以突破这个限制。
2.特点:    
    在后台服务的进程
    生存期很长
    守护进程独立于控制终端
        比如: init进程pid=1开机运行关机才结束
3.守护进程创建流程:
    1.创建子进程，父进程退出
        fork(void);
    2.在子进程中创建新会话
        setsid(void);
    3.修改工作目录
        chdir("");
    4.修改umask (增加安全性)
        umask();
    5.关闭文件描述(回收资源)
        close();
例：把进程变为守护进程，以下程序将进程的父进程改变为init()守护进程，关闭终端，不会将进程杀死，可通过kill命令杀死 
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <time.h>
#include <sys/types.h>
#include <sys/stat.h>

int main(int argc,const char *argv[]){
    pid_t pid = fork();
    if(pid < 0){
        perror("fork");
        exit(1);
    }
    else if(pid == 0){
        setsid();        //第二步：开启新的回话
        chdir("/tmp");    //第三步：改变工作目录
        umask(0);    //第四步：增加安全性
        close(0);
        close(1);        
        close(2);     //第五步：关闭文件描述符
        FILE *fp;
        while(1){
            fp = fopen("/tmp/test.txt","a");
            time_t t;
            time(&t);
            fprintf(fp,"%s",ctime(&t));
            fflush(fp); //因为fpintf是全缓存，所以需要强制刷新
            sleep(1);
        }
    }else{
        exit(0);  //第一步：父进程退出
    }
}

线程：

     线程是CPU能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位，
    一个进程可以开启多个线程，其中有一个主线程来调用本进程中的其他线程。
1.每个用户进程有自己的虚拟地址空间（32位机0~4G，64位机0~8G）
⒉.系统为每个用户进程创建一个task_struct结构体来描述该进程struct task_struct
3.task_struct和地址空间映射表一起用来表示一个进程
4.由于进程的虚拟地址空间是私有的，因此进程切换开销很大
5.为了提高系统的性能，linux引入轻量级进程,起名为线程
6.在同一个进程中创建的线程共享该进程的地址空间
7.Linux里同样用task_struct结构体来描述一个线程。线程和进程都参与统一的调度
总结:
    1.通常线程指的是共享相同虚拟地址空间的多个任务
    ⒉.使用多线程,大大提高了任务切换的效率
线程需要多大的虚拟内存？
     进程中的所有线程是共享进程的地址空间，但是系统会为每个线程分配独立的调用栈，也就说每个线程都会有一个自己的调用栈。所以线程需要的虚拟内存大小也就是我们的机器上调用栈的内存大小
每个进程中至少有一个线程，就是主线程，还可以产生多个线程共享4G内存空间，线程切换只需要虚拟CPU(寄存器)同样用task_struct结构体来描述一个线程，线程和进程都参于统一的调度
进程代表资源分配的最小单位
线程是最小的调度单位
当进程中只有一份线程时，进程和线程没有区别
当进程中有两个或两个以上时，进程和线程有区别
线程相关函数：
创建线程 
#include <pthread .h>

pthread_t tid;    //线程号

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

功能:创建线程

参数:thread：&tid    线程号的地址
     attr：NULL    默认参数（缺省参数）,线程的属性
     start_routine：线程函数的函数名  (第三个参数是一个回调函数)
         arg：给线程函数传递的参数，如果不传参写NULL

返回值:
    成功：0
    失败：错误码

compile and link with -pthread.    //gcc编译时需要链接pthread三方库

例：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>    
#include <time.h>

void *fun(void *arg);

int main(int argc,const char *argv[]){
    pthread_t tid;
    int ret = pthread_create(&tid,NULL,fun,NULL);
    if(ret == -1){
        perror("pthread_create");
        return -1;
    }
    while(1){
        printf("main is running!\n");
        sleep(1);
    }
    return 0;
}

void *fun(void *arg){
    while(1){
        printf("fun is running!\n");
        sleep(1);
    }
    return 0;
}

//两个线程运行时，cpu对他们的调度是随机的，没有先后
//编译时需要链接第三方pthread库，不然会报错 gcc mian.c -pthread

回收线程资源

int pthread_join(pthread_t thread，void **retva1);

功能:主线程等待子线程结束，回收它的资源（阻塞）
参数:
     thread ：线程号
     retval ：子线程的返回值
返回值:
     成功:0
     失败：-1    

int pthread_detach(pthread_t thread);
功能:主线程和子线程分离开来，自动回收资源（非阻塞)
参数:
    thread：线程号
返回值:
     成功：0
    失败：-1

例：阻塞状态，子进程结束，父进程回收子进程资源之后再继续

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

void *fun(void *arg);

int main(int argc,const char *argv[]){
    pthread_t tid;
    int ret = pthreat_create(&tid,NULL,fun,NULL);
    if(ret == -1){
        perror("pthreat_create");
        return -1;
    }
    printf("aaaaaaaaa\n");
    pthread_join(tid,NULL);
    printf("bbbbbbbbb\n");
    while(1);
    return 0;
}

void *fun(void *arg){
    int n = 5;
    while(n--){
        printf("fun is running!\n");
        sleep(1);
    }
    return 0;
}

例：非阻塞状态，子进程和父进程分离开来进行，子进程结束时父进程自动回收资源

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>    
void *fun(void *arg);

int main(int argc,const char *argv[]){
    pthread_t tid;
    int ret = pthreat_create(&tid,NULL,fun,NULL);
    if(ret == -1){
        perror("pthreat_create");
        return -1;
    }
    printf("aaaaaaaaa\n");
    pthread_detach(tid);
    printf("bbbbbbbbb\n");
    while(1);
    return 0;
}

void *fun(void *arg){
    int n = 5;
    while(n--){
        printf("fun is running!\n");
        sleep(1);
    }
    return 0;
}

多线程举例

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

void fun();

int main(int argc,const char *argv[]){
    pthread_t tid,tid1,tid2;
    int ret = pthreat_create(&tid,NULL,fun,NULL);
    if(ret == -1){
        perror("pthreat_create");
        return -1;
    }
    printf("aaaaaaaaa\n");
    pthread_detach(tid);

    pthread_create(tid1,NULL,fun1,NULL);
    pthread_detach(tid1);

    pthread_create(tid2,NULL,fun2,NULL);
    pthread_detach(tid2);

    printf("bbbbbbbbb\n");
    while(1);
    return 0;
}

void *fun(void *arg){
    int n = 3;
    while(n--){
        printf("fun is running!\n");
        sleep(1);
    }
    return 0;
}

void *fun1(void *arg){
    int n = 5;
    while(n--){
        printf("fun1 is running!\n");
        sleep(1);
    }
    return 0;
}

void *fun2(void *arg){
    int n = 7;
    while(n--){
        printf("fun2 is running!\n");
        sleep(1);
    }
    return 0;
}

//此处加上main函数这个线程，一共用4个线程

结束子线程

void pthread_exit(void *retva1);
功能:结束子线程
参数:
    retval : void *
返回值:
    成功：0
    失败：-1

线程传参的两种方式：值传递和地址传递

值传递

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

void *fun(void *arg);

int main(int argc,const char *argv[]){
    pthread_t tid;
    int count = 100;
    pthread_create(&tid,NULL,fun,(void *)count);    //这个地方的void *强转只是为了将count的值传递到join函数中，而join函数中是一个二级指针，所以进行强转
    void *m;    //定义一个一级指针
    pthread_join(tid,&m);    //对一级指针取地址 （结合函数定义：int pthread_join(pthread_t thread，void **retva1);）
    printf("%d %d\n",count,(int)m);
    return 0;
}

void *fun(void *arg){
    int m = (int)arg;    
    printf("%d\n",m);
    pthread_exit(arg);    //将arg的值返回，相当于return arg
}
结果：
100
100 100
编译运行会出现如下警告：
    warning: cast to pointer from integer of different size
原因：在ubuntu20.04中，void *类型和int类型的大小分别为8bit和4bit，所以会出现警告
join函数可以用来接收exit函数的返回值
fun函数中arg的类型是*类型，在main函数中要接收返回值，则需要对其取地址 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>    

void fun();

int main(int argc,const char *argv[]){
    pthread_t tid;
    int count = 100;
    pthread_create(&tid,NULL,fun,(void *)count);    
    while(1);
    return 0;
}

void *fun(void *arg){
    int m = (int)*(int *)arg;    
    printf("%d\n",m);
   }
结果：
100
100 100

地址传递

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

void *fun(void *arg);

int main(int argc,const char *argv[]){
    pthread_t tid;
    char buf[10] = "Hello";
    pthread_create(&tid,NULL,fun,(void *)buf);    
    void *arg;    //定义一个一级指针
    pthread_join(tid,&arg);    //对一级指针取地址 （结合函数定义：int pthread_join(pthread_t thread，void **retva1);）
    printf("%s %s\n",buf,(char *)arg);
    return 0;
}

void *fun(void *arg){
    char *p = (char *)arg;
    printf("%s\n",p);
    pthread_exit(arg);    //将arg的值返回，相当于return arg
}
结果：
Hello
Hello Hello

关闭线程

int pthread_cance1(pthread_t thread);

例：

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

void fun(void *arg);

int main(int argc,const char *argv[]){
    pthread_t tid;
    pthread_create(&tid,NULL,fun,(void *)buf);
    pthread_detach(tid);
    char buf[10] = {0};
    while(1){
        gtes(buf);
        if(strncmp(buf,"q",1) == 0){
            pthread_cancel(tid);
            }
        if(strncmp(buf,"Q",1) == 0){
            exit(0);
            }
    }
    return 0;
}
void fun(void *arg){
    printf("%s\n",arg);
}
结果：获取到键盘输入的字符数
优点：
    线程间很容易进行通信
    通过至局变量实现数据共享和交换
缺点:
    多个线程同时访问共享对象时需要引入同步和互斥机制
同步和互斥︰
    保护共享资源，避免竟态
    同步：多个任务按理想的顺序/步调来进行
    互斥：不能同时访问
都是为了避免竟态：多个任务同时访问共享资源

线程的同步----信号量

#include <semaphore.h>

sem_t sem;//信号量的变量

int sem_init(sem_t *sem，int pshared，unsigned int value);

功能:初始化信号量
参数:
    sem : &sem信号量的变量的地址
    pshared: 0 :线程    1 :进程
    value:信号量的初值
返回值:
    成功:0
    失败:-1
int sem_wait(sem_t *sem); //-1    
//如果初值为0，会阻塞

int sem_post(sem_t *sem); //+1    

先post再wait

例：主线程等待子线程结束

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

sem_t sem;
void *fun(void *arg);

int main(){
    sem_init(&sem,0,0);    //信号量的初始化
    pthreate_t tid;
    pthread_create(&tid,NULL,fun,NULL);
    printf("111111\n");
    sem_wait(&sem);    //会阻塞，因为初值赋的是0
    printf("222222\n");
}

void *fun(void *arg){
    int n = 5;
    while(n--){
        printf("333333\n");
        sleep(1);
        }
    sem_post(&sem);
    }
结果：
11111
33333
33333
33333
33333
33333
22222

线程的互斥----互斥锁

pthread_mutex_t mutex;    //互斥锁的变量
int pthread_mutex_init(pthread_mutex_t *mute,const pthread_mutexattr_t *mutexattr);
功能:初始化互斥锁
参数：
    mutex : &mutex
    mutexattr: NULL(默认属性)
返回值:
    成功:О
    失败:-1


int pthread_mutex_1ock(pthread_mutex_t *mutex);    //加锁

int pthread_mutex_unlock(pthread_mutex_t *mutex) ;    //解锁

例：不加互斥锁同时访问同一片地址空间

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

int i,value1,value2;
pthread_mutex_t mutex;

void *fun1(void *arg){
    while(1){
        i++;
        value1 = i;
        value2 = i;
    }
}

void *fun2(void *arg){
    while(1){
        if(value1 != value2){
            printf("%d %d %d",i,value1,value2);
            sleep(1);
        }
    }
}

int main(){
    pthread_t tid1,tid2;
    pthread_create(&tid1,NULL,fun1,NULL);
    pthread_detach(tid1);
    pthread_create(&tid2,NULL,fun2,NULL);
    pthread_detach(tid2);
}

例：加互斥锁

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

int i,value1,value2;
pthread_mutex_t mutex;

void *fun1(void *arg){
    while(1){
        pthread_mutex_lock(&mutex);
        i++;
        value1 = i;
        value2 = i;
        pthread_mutex_unlock(&mutex);
    }
}

void *fun2(void *arg){
    while(1){
        pthread_mutex_lock(&mutex);
        if(value1 != value2){
            printf("%d %d %d",i,value1,value2);
        }
        pthread_mutex_unlock(&mutex);
    }
}

int main(){
    //初始化互斥锁
    pthread_mutex_init(&mutex, NULL);
    pthread_t tid1,tid2;
    pthread_create(&tid1,NULL,fun1,NULL);
    pthread_detach(tid1);
    pthread_create(&tid2,NULL,fun2,NULL);
    pthread_detach(tid2);
}

Het_12
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux下多线程编程详解
01-27
废话不多说，先上一个线程...创建一个线程，函数的声明： thread_out创建线程后的标识符，下面会介绍。 attr设置线程属性。传NULL为默认属性（对大多数程序来说，使用默认属性就够了），当然具体使用下面也会做介绍。 s
exec函数族用法总结
不甘平凡的码农
11-19 1470
1、exec函数说明 fork()函数通过系统调用创建一个与原来进程（父进程）几乎完全相同的进程（子进程是父进程的副本，它将获得父进程数据空间、堆、栈等资源的副本。注意，子进程持有的是上述存储空间的“副本”，这意味着父子进程不共享这些存储空间。linux将复制父进程的地址空间内容给子进程，因此，子进程由了独立的地址空间。），也就是这两个进程做完全相同的事。 在fork后的子进程中使用exec函数族...
linux进程---exec族函数(execl, execlp, execle, execv, execvp, execvpe)
qiao代码的木偶人的博客
10-19 2271
exec族函数函数的作用： 我们用fork函数创建新进程后，经常会在新进程中调用exec函数去执行另外一个程序。当进程调用exec函数时，该进程被完全替换为新程序。因为调用exec函数并不创建新进程，所以前后进程的ID并没有改变。 在调用进程内部执行一个可执行文件。可执行文件既可以是二进制文件，也可以是任何Linux下可执行的脚本文件。 1.execl()代码实现： //文件execl.c #include <stdio.h> #include <stdlib.h> #in
exec函数族
hanchaoman的专栏
04-06 949
exec函数族也许有不少读者从本系列文章一推出就开始读，一直到这里还有一个很大的疑惑：既然所有新进程都是由fork产生的，而且由fork产生的子进程和父进程几乎完全一样，那岂不是意味着系统中所有的进程都应该一模一样了吗？而且，就我们的常识来说，当我们执行一个程序的时候，新产生的进程的内容应就是程序的内容才对。是我们理解错了吗？显然不是，要解决这些疑惑，就必须提到我们下面要介绍的exec系统调用
linux exec函数簇
ShenHang_的博客
06-09 467
fork创建子进程后执行的是和父进程相同的程序（但有可能执行不同的代码分支），子进程往往要调用一种exec函数以执行另一个程序。当进程调用一种exec函数时，该进程的用户空间代码和数据完全被新程序替换，从新程序的启动例程开始执行。调用exec并不创建新进程，所以调用exec前后该进程的id并未改变。 其实有六种以exec开头的函数，统称exec函数： int execl(const char *path, const char *arg, ...); //可变参数函数，即参数个数可变的函数。 int ex
如何在VC++中使用注册表
leapar的专栏
07-12 1600
 如何在VC++中使用注册表 --------------------------------------------------------------------------------　　 如今修改注册表成为继超频之后的又一大热点，许多CFAN通过对注册表的修改使Win98显得更加个性化，诸多报刊杂志也纷纷扯起注册表这面旗帜，令人遗憾的是，在介绍注册表修改的众多的文章中，大都以手
linux线程编程-详解
08-20
linux线程编程函数pthread_create与pthread_join详解
详解Linux多线程使用信号量同步
01-20
但是下面介绍的信号量的接口是用于线程的信号量，注意不要跟用于进程间通信的信号量混淆。 一、什么是信号量 线程的信号量与进程间通信中使用的信号量的概念是一样，它是一种特殊的变量，它可以被增加或减少，但对其...
详解Linux多线程编程（不限Linux）
01-20
还有多线程编程的一些细节问题，如线程之间怎样同步、互斥，这些东西将在本文中介绍。我在某QQ群里见到这样一道面试题： 是否熟悉POSIX多线程编程技术？如熟悉，编写程序完成如下功能： 1）有一int型全局变量g_Flag...
使用GDB调试多线程实例详解
01-10
pthread不是Linux下的默认的库，也就是在链接的时候，无法找到phread库中哥函数的入口地址，于是链接会失败。在gcc编译的时候，附加要加 -lpthread参数即可解决。 gdb test 进入调试 需要调试的地方打下断点，run...
linux 原子操作函数簇
weixin_30511107的博客
03-21 113
备忘录。测试下行为，然后封装下，跨平台的原子操作就可以了。一下内容来自：http://gcc.gnu.org/onlinedocs/gcc/Atomic-Builtins.html#Atomic-Builtins 6.51 Built-in functions for atomic memory access The following builtins are intended to be ...
exec函数簇
一夜落尽梧桐雨 的博客
06-12 599
函数声明 包含头文件 #include <unistd.h> execl int execl(const char *path, const char *arg, ... /* (char *)NULL */); execlp int execlp(const char *file, const char *arg, ... /* (char *)NULL */); execle in
ucontext簇函数学习
abcd1f2的专栏
08-05 1445
ucontext簇函数学习 作者: fergus ([email protected]) 系统手册学习： 名字 getcontext, setcontext —— 获取或者设置用户上下文 概要 #include ucontext.h> int getcontext(ucontext_t *ucp); int setcontext(const ucontex
exec函数
weixin_34273479的博客
07-27 91
1.exec家族一共有六个函数，分别是：(1)int execl(const char *path, const char *arg, ......);(2)int execle(const char *path, const char *arg, ...... , char * const envp[]);(3)int execv(const char *path, cha...
execl函数族
fwc5357的博客
05-25 731
#include <unistd.h> extern char **environ; int execl(const char *path, const char *arg, …); int execlp(const char *file, const char *arg, …); int execle(const char *path, const char *arg, …, ch...
小记——exec函数簇
心清的专栏
07-19 972
#include int execl(const char* path, const char *arg, ...); int execlp(const char *file, const char *arg, ...); int execle(const char *path, const char *arg, ..., char * const envp[]); int execv(
簇函数——捆绑函数
Destiny_LI的博客
04-16 1246
簇的捆绑函数功能
gloriasz的博客
04-16 4636
一、目的 学会如何使用捆绑函数及其注意事项，注意簇中可以包含不同元素类型，但只能同为输入或输出。 二、VI前面板 三、VI的程序框图 四、心得 捆绑函数要求所有的输入断点都必须连接输入元素，输入元素可以是不同类型，同样也可以连接包含输入类型的簇。
exec函数簇的使用
liuhuiyan_2014的专栏
04-18 820
#include #include using namespace std; int main(int argc,char *argv[]) { execl("/bin/ls","-l",NULL);//1 execv("/bin/ls",&argv[1]);//2 execle("/bin/ls","-l",(char *)0,NULL);//3 execve("/bin
inux c 获取进程p id,详解linux获取线程的pid(tid、lwp)的几种方式
最新发布
09-02
总结：在Linux C编程中，我们可以使用getpid()函数来获取进程的PID，gettid()函数或者syscall(SYS_gettid)来获取线程的TID或LWP。另外，pthread_self()函数也可以获取当前线程的标识符。使用这些方法可以方便地获取...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值