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

已于 2023-03-20 19:43:47 修改
阅读量779 收藏 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
关注
专栏目录
Linux C++多线程同步的四种方式（非常详细）
Y先森0.0
07-15 1万+
背景问题：在特定的应用场景下，多线程不进行同步会造成什么问题？通过多线程模拟多窗口售票为例：#include <iostream> #include<pthread.h> #include<stdio.h> #include<stdlib.h> #include<string.h> #include<unistd.h> us...
实现linux的互斥量c++封装
weixin_34137799的博客
06-21 106
先贴示范代码：//--------------------tmutex.h开始------------------------------//实现linux的互斥量c++封装#ifndef TMUTEX_H#define TMUTEX_H#include <pthread.h>//线程互斥量struct ThreadMutex{ ThreadMutex() ...
最全面的教程 C++使用mutex锁（语言提供+linux+windowns三种平台锁的使用）
最新发布
喜欢就关注吧
08-19 506
最全面的C++使用锁的教程
Linux下C/C++ 多线程同步
jxluoix的专栏
04-02 199
#include &lt;pthread.h&gt; #include "PosixMutexLock.hpp"   #ifndef POSIX_SYNC #define POSIX_SYNC class PosixSync  { private:   protected:   PosixMutexLock *lock;   pthread_cond_t block;...
Posix多线程编程学习笔记（四）—互斥量（1）
ljx0305的专栏
08-01 730
  一、什么是互斥锁       另一种在多线程程序中同步访问手段是使用互斥量。程序员给某个对象加上一把“锁”，每次只允许一个线程去访问它。如果想对代码关键部分的访问进行控制，你必须在进入这段代码之前锁定一把互斥量，在完成操作之后再打开它。        互斥量函数有       pthread_mutex_init 初始化一个互斥量       pthread_mut
Linux多线程C++版（九） 线程同步和互斥-----线程信号量
kaszxc的博客
12-08 1024
【代码】Linux多线程C++版（九） 线程同步和互斥-----线程信号量。 1.基本概念 2.信号量创建和销毁 3.信号量加和减操作 4.代码理解信号量 5.信号量实例银行账户取款----实现互斥 6.信号量实例计算和取结果----实现线程同步
Linux多线程使用互斥量同步线程
09-15
### Linux多线程使用互斥量同步线程 #### 一、什么是互斥量 互斥量（Mutex，Mutual Exclusion Object）是一种用于多线程编程中的同步机制，其目的是确保同一时间只有一个线程可以访问共享资源或临界区。这种机制...
c++ 多线程向同一个文本写入信息 解决同步与互斥问题
12-23
c++ 多线程向同一个文本写入信息 解决同步与互斥问题
linux上实现多进程和多线程实现同步互斥（源代码）
04-18
在Linux操作系统中，多进程和多线程是两种并发执行的方式，它们在处理并发问题时，经常需要进行同步和互斥操作，以确保数据的一致性和程序的正确性。本篇将详细介绍这两种并发模型以及如何在Linux环境中实现同步互斥...
Linux下多线程编程的互斥与同步
07-31
在Linux系统中，多线程编程常常涉及到线程间的互斥与同步，这是为了确保并发执行的线程在访问共享资源时不会发生数据竞争或不一致的状态。互斥锁是实现这一目标的基本工具，它保证同一时刻只有一个线程能够持有锁并...
Linux c++多线程串口编程demo
01-26
通过这个demo，你可以学习如何在Linux环境下使用C++进行多线程串口编程，理解线程同步的概念，以及如何处理硬件交互。对于理解和应用这些技术，阅读和分析源代码将是至关重要的。同时，这个项目也可以作为进一步研究...
c++多线程的创建挂起执行与销毁
03-21
1. 创建一个基于对话框的应用程序。并增加如图所示控件；分别为3个进度条控件关联三个进度条类型的变量；并在对话框的初始化函数中，设定进度条的范围；为编辑框关联一个整型的变量；为12个按钮添加消息处理函数； 2. 定义结构体：用做线程函数的参数传递 typedef struct Threadinfo{ CProgressCtrl *progress;//进度条对象 int speed; //进度条速度 int pos; //进度条位置 } thread,*lpthread; 3. 为对话框增加三个句柄，用于标识各个线程； HANDLE hThread1; //线程1线程句柄 HANDLE hThread2; //线程2线程句柄 HANDLE hThread3; //线程3线程句柄 在增加三个结构体类型的变量，用做线程函数的参数传递； HANDLE hThread1; //线程1线程句柄 HANDLE hThread2; //线程2线程句柄 HANDLE hThread3; //线程3线程句柄 4. 新增一个静态的全局变量，用于记录所有线程的状态：static int GlobalVar=10000; 5. 声明并编写线程函数，注意只能有一个参数，且函数的返回值类型也是固定的；函数名可以自定义； DWORD WINAPI ThreadFun(LPVOID pthread);//线程入口函数 6. 在启动按钮的消息处理函数中编写如下代码： thread1.progress=&m_progress1;//进度条对象 thread1.speed=100;//速度 thread1.pos=0;//初始位置 hThread1=CreateThread(NULL,0,ThreadFun,&thread1;,0,0);//创建并开始线程 if (!hThread1) { MessageBox("创建线程失败"); } 7. 编写线程函数（一般是一个死循环，或者需要花费时间很长的算法！否者就失去了多线程的意义） DWORD WINAPI ThreadFun(LPVOID pthread) //线程入口函数 { lpthread temp=(lpthread)pthread;//参数强制转换为结构体类型 temp->progress->SetPos(temp->pos); //设置被传递过来的进度条的位置 while(temp->posspeed); /设置速度 temp->pos++; //增加进度 temp->progress->SetPos(temp->pos); //设置进度条的新位置 GlobalVar--; if(temp->pos==20) { temp->pos=0; //进度条满则归0 } } return true; } 8. 在挂起按钮函数中，编写如下代码： if(SuspendThread(hThread1)==0xFFFFFFFF) { MessageBox("挂起失败！进程可能已经死亡或未创建！"); return; } 9. 在执行按钮函数中，编写如下代码： if(ResumeThread(hThread1)==0xFFFFFFFF) { MessageBox("执行失败！进程可能已经死亡或未创建！"); return; } 10. 在停止按钮函数中，编写如下代码： if(TerminateThread(hThread1,0))//前些终止线程 { CloseHandle(hThread1);//销毁线程句柄 } else { MessageBox("终止进程失败！"); } 11. 为应用程序添加WM_TIMER消息，实时更新全局变量的值到编辑框；
Linux C++实现多线程同步(超级详细）
huang714的专栏
08-25 697
通过多线程模拟多窗口售票为例： #include <iostream> #include<pthread.h> #include<stdio.h> #include<stdlib.h> #include<string.h> #include<unistd.h> using namespace std; int ticket_sum=20; void *sell_ticket(void *arg) { for(in
Linux中基于c++多线程编程学习杂记：线程同步
m0_68731112的博客
05-19 340
文章转载自爱编程的大丙
Linux/C++多线程编程学习笔记——线程同步、锁
mwz18959217316的博客
09-20 736
linux/C++线程同步机制，锁
线程同步(Linux_C++)
cherish_2012的专栏
09-07 571
线程的同步 互斥锁,读写锁,条件变量有两种方式创建 在 posix 互斥锁,读写锁,条件变量有两种方式创建.静态方式和动态方式. POSIX定义了三个个宏: PTHREAD_MUTEX_INITIALIZER  来静态初始化互斥锁PTHREAD_COND_INITIALIZER  来静态初始化条件变量PTHREAD_RWLOCK_INITIALIZER  来静态初始
多线程编程5：线程同步和进程通信(C++11和linux)
yubaoaihh
08-04 413
线程同步和进程通信(C++11和linux)
linux进程之间互斥
baidu20008的专栏
04-15 4177
总所周知，在linux中pthread_mutex_t
linux c++之互斥变量和条件变量
weixin_33907511的博客
11-30 97
https://blog.csdn.net/dasgk/article/details/36915225
Linux多线程互斥与同步实践：N2(9S系统中的线程机制
"这篇文档是关于Linux操作系统编程的，特别是多线程的互斥与同步控制，适合进阶学习者和实践者。文中探讨了线程的概念，如何在Linux（N2(9S系统）中实现线程机制，并介绍了线程间的互斥与同步策略，以确保多线程程序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Unknown To Known

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

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

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

打赏作者

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

抵扣说明：

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

余额充值