Linux多线程C++版（六） 线程同步和线程互斥

已于 2023-03-20 19:43:47 修改
阅读量769 收藏 3
点赞数 1
分类专栏： C++ Linux多线程 Linux
于 2022-11-26 11:22:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kaszxc/article/details/128049575
版权

线程同步 互斥锁 ATM取款 进程共享 锁类型
关键词由CSDN通过智能技术生成
C++ 同时被 3 个专栏收录
47 篇文章 5 订阅
订阅专栏
Linux
16 篇文章 2 订阅
订阅专栏
Linux多线程
9 篇文章 3 订阅
订阅专栏

目录

1.线程同步和线程互斥
  • 线程同步
    • 线程同步是一个宏观概念，在微观上包含线程的相互排斥和线程先后执行的约束问题。
    • 解决同步方式
      • 条件变量
      • 线程信号量
  • 线程互斥
    • 线程执行是相互排斥
    • 解决互斥方式
      • 互斥锁
      • 读写锁
      • 线程信号量
2.线程互斥案例—ATM取钱–没有使用互斥锁

头文件 account.h

#ifndef __ACCOUNT_H__
#define __ACCOUNT_H__
//银行账户结构体
typedef struct{
    int code;//卡号
    double balance;//余额
}Account;
//创建账户
extern Account* creat_account(int code,double balance);
//销毁账户
extern void destory_account(Account *a);
//取款
extern double withdraw(Account *a,double amt);
//存款
extern double deposit(Account *a,double amt);
//查看账户余额
extern double get_balance(Account *a);
#endif

功能文件account.c

#include "account.h"
#include <malloc.h>
#include <assert.h>
#include <string.h>

//创建账户
Account* creat_account(int code,double balance){
    //创建账户在堆当中
    Account *a = (Account*)malloc(sizeof(Account));
    assert(a != NULL);//用来判断a指针所需要开辟的空间，开辟成功了吗，成功就继续，否则就程序终止运行。
    a->code = code;
    a->balance = balance;
    return a;
}
//销毁账户
void destory_account(Account *a){
    assert(a != NULL);
    free(a);//释放空间
}
//取款
double withdraw(Account *a,double amt){
    if(amt < 0 || amt > a->balance){
        return 0.0;
    }
    double balance = a->balance;
    sleep(1);
    balance -= amt;
    a->balance = balance;
    return amt;
}
//存款
double deposit(Account *a,double amt){
   assert(a != NULL);
   if(amt < 0){
       return 0.0;
   }
    double balance = a->balance;
    sleep(1);
    balance += amt;
    a->balance = balance;
    return amt;
}
//查看账户余额
double get_balance(Account *a){
    assert(a != NULL);
    double balance = a->balance;
    return balanec;
}

执行文件 account_test.c

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

//操作者的结构体
typedef struct{
    char  name[20];//操作者姓名
    Account *account;//账户
    double amt;//金额
}OperArg
//定义取款操作的线程运行函数
void* withdraw_fn(void *arg){
    OperArg *oa = (OperArg*)arg;
    //deposit存款函数
    double amt = deposit(oa->account,oa->amt);
    printf("%8s(0x%lx) deposit %f from account %d/n",oa->name,pthread_self(),amt,oa->account->code);
    return (void*)0;
}
//定义存款操作的线程运行函数
void* deposit_fn(void *arg){
    OperArg *oa = (OperArg*)arg;
    //withdraw取款函数
    double amt = withdraw(oa->account,oa->amt);
    printf("%8s(0x%lx) withdraw %f from account %d/n",oa->name,pthread_self(),amt,oa->account->code);
    return (void*)0;
}
//定义查看银行账户的线程运行函数
void* check_fn(void *arg){
    
}
int main(void){
    int err;
    pthread_t boy,girl;
    Account *a = create_account(10001,10000)//卡号，余额
        
    OperArg o1 , o2;//两个操作者
    strcpy(o1.name,"boy");//strcpy()把第二个参数值，放到第一个参数中
    o1.account = a;
    o1.amt = 10000;
    
    strcpy(o2.name,"girl");
    o2.account = a;
    o2.amt = 10000;
    
    //启动两个子线程（boy和girl）同时去操作同一个银行账户
    if((err = pthread_create(&boy,null,withdraw_fn,(void*)&o1)!=0){
        printf("pthread create error");
    }
    if((err = pthread_create(&girl,null,withdraw_fn,(void*)&o2)!=0){
        printf("pthread create error");
    }
    
    pthread_join(boy,null);
    pthread_join(girl,null);
       
    //查看账户余额
    printf("account balance %f/n",get_balance(a));
    //销毁账户
    destroy_account(a);
    return 0;
}

程序输出结果：

在这里插入图片描述

girl和boy都从银行账户10001中取出了10000元，所以产生了错误。

3.线程互斥----互斥锁(互斥量)
  • 互斥锁是一种简单的加锁的方法，来控制对共享资源的访问。在同一时刻只能有一个线程掌握某个互斥锁，拥有上锁状态的线程能够对共享资源进行访问。若其他线程希望上锁一个已经被上了互斥锁的资源，则该线程挂起，直到上锁的线程释放互斥锁为止。
  • 互斥锁数据类型
    • pthread_mutex_t
4.互斥锁创建和销毁
//锁的定义
pthreat_mutex_t  mutex;
//锁的初始化
int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthreat_mutex_t *mutexattr);
//锁的销毁
int pthread_mutex_destroy(pthreat_mutex_t *mutex);
返回：成功返回 0  否则返回错误编号
  • 参数
    • mutex :互斥锁
    • mutexattr：互斥锁创建方式 或者可以传入锁的属性后面会有
      • PTHREAD_MUTEX_INITIALIZER(默认) 创建快速互斥锁 第一次上锁成功，第二次上锁会阻塞
      • PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP 创建递归互斥锁 第一次上锁成功，第二次以后上锁还是成功，内部计数
      • PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP 创建检错互斥锁 第一次上锁成功，第二次上锁会出错
5.互斥锁上锁和解锁
int pthread_mutex_lock(pthread_mutex_t *mutex); //上锁  上不了锁该线程就阻塞
int pthread_mutex_trylock(pthread_mutex_t *mutex); //上锁 上不了锁该线程就返回错误信息
int pthread_mutex_unlock(pthread_mutex_t *mutex); //释放锁
返回：成功返回 0 出错返回出错码
  • 参数
    • mutex ：互斥锁
6.线程互斥案例—ATM取钱–使用互斥锁

头文件 account.h

#ifndef __ACCOUNT_H__
#define __ACCOUNT_H__
#include <pthread.h>
//银行账户结构体
typedef struct{
    int code;//卡号
    double balance;//余额
    //定义一把互斥锁，用来对多线程操作
    //银行账户（共享资源）进行加锁保护
    /*
    	建议互斥锁和账户(共享资源)绑定一起，用来锁定一个账户（共享资源）
    	尽量不设置全局变量，否则肯能出现一把锁去锁几百个账户，导致并发性能降低
    */
    pthread_mutex_t mutex;
    
}Account;
//创建账户
extern Account* creat_account(int code,double balance);
//销毁账户
extern void destory_account(Account *a);
//取款
extern double withdraw(Account *a,double amt);
//存款
extern double deposit(Account *a,double amt);
//查看账户余额
extern double get_balance(Account *a);
#endif

功能文件account.c

#include "account.h"
#include <malloc.h>
#include <assert.h>
#include <string.h>

//创建账户
Account* creat_account(int code,double balance){
    //创建账户在堆当中
    Account *a = (Account*)malloc(sizeof(Account));
    assert(a != NULL);//用来判断a指针所需要开辟的空间，开辟成功了吗，成功就继续，否则就程序终止运行。
    a->code = code;
    a->balance = balance;
    //对互斥锁进行初始化
    pthread_mutex_init(&a->mutex,null);
    return a;
}
//销毁账户
void destory_account(Account *a){
    assert(a != NULL);
    //销毁互斥锁
    pthread_mutex_destroy(&a->mutex)
    free(a);//释放空间
}
//取款
double withdraw(Account *a,double amt){
    assert(a != NULL);//判断指针a是否为空
    /*
    	从成功上锁，到释放锁之间对共享资源操作的区间称为临界区
    */
    pthread_mutex_lock(&a->mutex);//对共享共享资源（账户）加锁
    //有线程执行到此时，账户加锁，当其他线程执行到此时，就会被堵塞
        
    if(amt < 0 || amt > a->balance){
        //释放互斥锁
        pthread_mutex_unlock(&a->mutex);
        return 0.0;
    }
    double balance = a->balance;
    sleep(1);
    balance -= amt;
    a->balance = balance;
    //释放互斥锁
    pthread_mutex_unlock(&a->mutex);
    return amt;
}
//存款
double deposit(Account *a,double amt){
   assert(a != NULL);
   pthread_mutex_lock(&a->mutex)//对共享共享资源（账户）加锁
   if(amt < 0){
       //释放互斥锁
       pthread_mutex_unlock(&a->mutex);
       return 0.0;
   }
    double balance = a->balance;
    sleep(1);
    balance += amt;
    a->balance = balance;
    //释放互斥锁
    pthread_mutex_unlock(&a->mutex);
    return amt;
}
//查看账户余额
double get_balance(Account *a){
    assert(a != NULL);
    pthread_mutex_lock(&a->mutex)//对共享共享资源（账户）加锁
    double balance = a->balance;
    //释放互斥锁
    pthread_mutex_unlock(&a->mutex);
    return balanec;
}

执行文件 account_test.c

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

//操作者的结构体
typedef struct{
    char  name[20];//操作者姓名
    Account *account;//账户
    double amt;//金额
}OperArg
//定义取款操作的线程运行函数
void* withdraw_fn(void *arg){
    OperArg *oa = (OperArg*)arg;
    //deposit存款函数
    double amt = deposit(oa->account,oa->amt);
    printf("%8s(0x%lx) deposit %f from account %d/n",oa->name,pthread_self(),amt,oa->account->code);
    return (void*)0;
}
//定义存款操作的线程运行函数
void* deposit_fn(void *arg){
    OperArg *oa = (OperArg*)arg;
    //withdraw取款函数
    double amt = withdraw(oa->account,oa->amt);
    printf("%8s(0x%lx) withdraw %f from account %d/n",oa->name,pthread_self(),amt,oa->account->code);
    return (void*)0;
}
//定义查看银行账户的线程运行函数
void* check_fn(void *arg){
    
}
int main(void){
    int err;
    pthread_t boy,girl;
    Account *a = create_account(10001,10000)//卡号，余额
        
    OperArg o1 , o2;//两个操作者
    strcpy(o1.name,"boy");//strcpy()把第二个参数值，放到第一个参数中
    o1.account = a;
    o1.amt = 10000;
    
    strcpy(o2.name,"girl");
    o2.account = a;
    o2.amt = 10000;
    
    //启动两个子线程（boy和girl）同时去操作同一个银行账户
    if((err = pthread_create(&boy,null,withdraw_fn,(void*)&o1)!=0){
        printf("pthread create error");
    }
    if((err = pthread_create(&girl,null,withdraw_fn,(void*)&o2)!=0){
        printf("pthread create error");
    }
    
    pthread_join(boy,null);
    pthread_join(girl,null);
       
    //查看账户余额
    printf("account balance %f/n",get_balance(a));
    //销毁账户
    destroy_account(a);
    return 0;
}

程序运行结果：

在这里插入图片描述

7.互斥锁属性创建和销毁
//互斥锁属性的初始化
int pthread_mutexattr_init(pthread_mutexattr_t *attr);
//互斥锁属性的销毁
int pthread_mutexattr_destroy(pthread_mutexattr_t *attr)
  • 参数
    • attr：互斥锁属性定义
8.互斥锁属性之一—进程共享属性操作
//restrict用于限定和约束指针，表示这个指针只访问这块内存的唯一方式
//共享属性获取，pshared用于存放获取的共享属性
int pthread_mutexattr_getpshared(const pthread_mutexattr_t *restrict attr,int *restrict pshared);
//共享属性设置，pshared用于指定共享属性
int pthread_mutexattr_setpshared(const pthread_mutexattr_t *attr,int pshared);
返回：成功返回0，出错返回错误编号
  • 参数
    • attr：互斥锁属性
    • pshared：进程共享属性
      • PTHREAD_PROCESS_PRIVATE(默认情况) 锁只能用于一个进程内部的两个进程进行互斥
      • PTHREAD_PROCESS_SHARED 锁可以用于两个不同进程中的线程进行互斥
9.互斥锁属性之一----互斥锁类型操作
//restrict用于限定和约束指针，表示这个指针只访问这块内存的唯一方式
//共享属性获取，pshared用于存放获取的共享属性
int pthread_mutexattr_gettype(const pthread_mutexattr_t *restrict attr,int *restrict type);
//共享属性设置，pshared用于指定共享属性
int pthread_mutexattr_settype(const pthread_mutexattr_t *attr,int type);
返回：成功返回0，出错返回错误编号
  • 参数
    • attr：互斥锁属性
    • type：互斥锁类型
      • 标准互斥锁：PTHREAD_MUTEX_NORMAL 第一次上锁成功，第二次上锁会阻塞
      • 递归互斥锁：PTHREAD_MUTEX_RECURSIVE 第一次上锁成功，第二次以后上锁还是成功，内部计数
      • 检错互斥锁：PTHREAD_MUTEX_ERRORCHECK 第一次上锁成功，第二次上锁会出错
      • 默认互斥锁：PTHREAD_MUTEX_DEFAULT(同标准互斥锁)
10.代码了解互斥锁属性
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc,char *argv[]){
    //定义锁
    pthread_mutex_t mutex;
    
    if(argc<2){
        printf("-usage:%s [error|normal|recursive]/n",argv[0]);
        exit(1);
    }
    
    //定义互斥锁属性
    pthread_mutexatte_t  mutexattr;
    //初始化互斥锁属性
    pthread_mutexattr_init(&mutexattr);
    
    /*
    	strcmp函数用于比较两个字符串并根据比较结果返回整数。
    	基本形式为strcmp(str1,str2)，
    	若str1=str2，则返回零；
    	若str1<str2，则返回负数；
    	若str1>str2，则返回正数。
    */
    if(!strcmp(argv[1]),"error"){
        //设置互斥锁类型---检错型
        pthread_mutexattr_settype(&mutexattr,PTHREAD_MUTEX_ERRORCHECK);
    }else if(!strcmp(argv[1],"normal")){
        //设置互斥锁类型---标准型
        pthread_mutexattr_settype(&mutexattr,PTHREAD_MUTEX_NORMAL);
    }else if(!strcmp(argv[1],"recursive")){
        //设置互斥锁类型---递归型
        pthread_mutexattr_settype(&mutexattr,PTHREAD_MUTEX_RECURSIVE );
    }
    //锁的初始化，第一个参数传入锁，第二个参数可以指定，也可以传入锁的属性，
    pthread_mutex_init(&mutex,&mutexattr)
    //上锁
    if(pthread_mutex_lock(&mutex) !=0){
        printf("lock failure\n");
    }else{
         printf("lock sucess\n");
    }
    //第二次上锁
    if(pthread_mutex_lock(&mutex) !=0){
        printf("lock failure\n");
    }else{
         printf("lock sucess\n");
    }
    
    //上了两次锁，解锁两次
    pthread_mutex_unlock(&mutex);
    pthread_mutex_unlock(&mutex);
    
    //销毁属性
    pthread_mutexattr_destroy(&mutexattr);
}

程序运行结果：

​ 选择normal，锁的类型是普通型，第一次上锁成功，第二次失败，程序阻塞

​ 选择recursive，锁的类型是递归性，第一次上锁成功， 第二次也成功，只是内部计数。

​ 选择error，锁的类型是检错型，第一次上锁成功，第二次失败，程序报错
在这里插入图片描述
在这里插入图片描述

Unknown To Known
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Linux多线程使用互斥量同步线程
09-15
本文主要介绍了Linux多线程使用互斥量同步线程，详细介绍了互斥量的使用，有需要的可以了解一下。
Linux下多线程编程的互斥与同步
07-31
在Linux系统中，多线程编程常常涉及到线程间的互斥与同步，这是为了确保并发执行的线程在访问共享资源时不会发生数据竞争或不一致的状态。互斥锁是实现这一目标的基本工具，它保证同一时刻只有一个线程能够持有锁并...
【linux多线程】c++多线程的同步方式
shuaixio的博客
05-01 1767
linux多线程，C++多线程，线程同步，互斥锁，条件变量，读写锁，自旋锁，信号量，关卡
Linux多线程——互斥和同步，死锁
weixin_57023347的博客
09-24 1832
一.线程互斥 1.1 相关概念 临界资源：多线程执行流共享的资源叫临界资源。 并不一定所有的共享资源是临界资源，是多个线程访问的资源才是临界资源。 临界区：每个线程内部，访问临界资源的代码，叫做临界区。 互斥：任何时刻，互斥保证有且只有一个执行流进入临界区，访问灵界资源，通常对临界资源起保护作用。一个能进，一个不能进 原子性：不会被人后调度机制打断的操作，该操作只有两态，要么完成，要么未完成，没有中间态。可以理解成只有一个汇编代码。比如修改一个变量，一个执行流进来，要修改时，又有一...
一文详解C++多线程
非晚非晚的博客
04-25 7万+
传统的C++（C++11之前）中并没有引入线程这个概念，在C++11出来之前，如果我们想要在C++中实现多线程，需要借助操作系统平台提供的API，比如Linux的，或者windows下的 。C++11提供了语言层面上的多线程，包含在头文件中。它解决了跨平台的问题，提供了管理线程、保护共享数据、线程间同步操作、原子操作等类。C++11 新标准中引入了5个头文件来支持多线程编程，如下图所示：
【Linux C | 多线程编程】线程同步 | 互斥量(互斥锁)介绍和使用
wkd_007的博客
04-08 1404
本文介绍了Linux系统下，多线程编程常用的互斥量，先是介绍了需要互斥量的原因，然后介绍互斥量的使用，并给出使用例子。
【Linux】线程互斥和同步
lzb_kkk的博客
07-21 1660
Linux中线程互斥的概念，互斥量mutex的介绍，如何初始化互斥量，销毁互斥量，互斥量加锁/解锁；可重入和线程安全的概念和联系，及其区别;Linux中死锁的概念，死锁的四个必要条件，如何避免死锁，常见避免死锁的算法；线程同步中条件变量的初始化，销毁条件变量，如何让线程在条件变量中进行排队等待，以及如何唤醒等待队列中的线程；cp问题生产者和消费者模型的代码实现
C++11 多线程（std::thread）详解
热门推荐
jcShan709的博客
07-17 10万+
注：此教程以 Visual Studio 2019 Version 16.10.3 （MSVC 19.29.30038.1) 为标准 文章目录线程？进程？多线程？什么是多线程？进程与线程的区别C++11的std::threadstd::thread常用成员函数构造&析构函数常用成员函数举个栗子例一：thread的基本使用例二：thread执行有参数的函数例三：thread执行带有引用参数的函数注意事项（剩下的内容还没写完，明天再更） 线程？进程？多线程？ 什么是多线程？ 百度百科中的解释： 多.
C++11 - thread多线程编程，线程互斥和同步通信，死锁问题分析解决
大秦坑王的专栏
04-01 1万+
c++11 thread线程库使用，线程互斥，互斥锁，死锁问题分析定位
【C++】多线程同步
目标：MVP
02-21 6873
线程间的同步方法大体可以分为两类：用户模式和内核模式。内核模式就是指利用系统内核对象的单一性来进行同步，使用时需要切换内核态与用户态，而用户模式就是不需要切换到内核态，只在用户态完成操作。 用户模式下的方法有：原子操作（例如一个单一的全局变量）、临界区。特点是：同步速度特别快。 内核模式下的方法有：事件、信号量、互斥量。同步速度较慢，但适用性比较好。 **临界区：**通过对多线程的串行化来访问公共资源或一段代码、速度快，适合控制数据访问。 **互斥量：**为协调共同对一个共享资源的单独访问而设计的。 *
【Linux】线程互斥与同步
m0_51064412的博客
03-12 3321
文章目录一. 什么是互斥？二. 为什么要有互斥？三. 互斥量实现互斥 一. 什么是互斥？ 在介绍什么是互斥之前需要了解下面三个概念： 临界资源：多线程执行流共享的资源就叫做临界资源。 临界区：每个线程内部，访问临界资源的代码，就叫做临界区。 原子性：不会被任何调度机制打断的操作，该操作只有两态，要么完成，要么未完成。 互斥：任何时刻，互斥保证有且只有一个执行流进入临界区，访问临界资源，通常对临界资源起保护作用 二. 为什么要有互斥？ 大部分情况，线程使用的数据都是局部变量，变量的地址空间在线程私有栈空间
线程及线程的同步互斥
weixin_45738899的博客
06-13 2060
目录线程的简单介绍信号量互斥量条件变量1.线程的简单介绍 线程的简单介绍 信号量 互斥量 条件变量 1.线程的简单介绍
c++ 多线程向同一个文本写入信息 解决同步与互斥问题
12-23
c++ 多线程向同一个文本写入信息 解决同步与互斥问题
Linux c++多线程串口编程demo
01-26
通过这个demo，你可以学习如何在Linux环境下使用C++进行多线程串口编程，理解线程同步的概念，以及如何处理硬件交互。对于理解和应用这些技术，阅读和分析源代码将是至关重要的。同时，这个项目也可以作为进一步研究...
linux线程间的同步与互斥知识点总结
09-14
总结来说，线程同步和互斥是保证多线程程序正确性的关键。条件变量提供了灵活的同步机制，允许线程在满足特定条件时才继续执行，而互斥锁则确保了对临界资源的独占访问。理解并熟练运用这些机制，开发者可以在编写多...
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1194
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
C++ primer plus 第16章string 类和标准模板库, 关联容器
最新发布
zhyjhacker的博客
07-25 662
C++ primer plus 第16章string 类和标准模板库, 关联容器。
VS2019编译和使用gtest测试（C++）
m0_65635427的博客
07-24 272
下载下来解压到文件夹，再在文件夹里面新建一个build文件夹，如下：再安装cmake，可以先检查一下是否安装了cmake，打开命令窗口，输入cmake -version：然后双击就对了，我这里已经安装好了，无法提供截图，注意一点就是在让选择是否建立系统环境变量（path）的时候，记得勾上第二个建立系统环境变量！下载好之后，记得检验一下是否安装成功，如果在普通用户下显示没有，建议用管理员身份打开命令窗口，再次尝试。之后命令窗口进入创建的build文件夹路径里面执行cmake ../
【C++修炼之路 第五章】string 类（补充）：string 扩展空间规律 + reserve 的缩容 + resize 的使用
唯有忍受别人不能忍受的，才能享受别人不能享受的
07-23 1133
【详细剖析】string 扩展空间规律 + reserve 的缩容性质与只改变capacity的性质 + resize 的使用 + shink_to_fit 的缩容函数
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Unknown To Known

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值