C++多线程学习笔记11（WINDOWS临界区、自动析构技术、recursive_mutex 递归的独占互斥量、带超时功能的独占互斥量 std::timed_mutex）

最新推荐文章于 2023-06-12 22:46:01 发布
最新推荐文章于 2023-06-12 22:46:01 发布
阅读量488 收藏
点赞数
分类专栏： C++多线程 文章标签： c++ windows 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43142607/article/details/122581021
版权

1.WINDOWS临界区
同一个线程中，windows"相同临界区变量代表临界区"的进入
EnterCriticalSection(&my_winsec) 和LeaveCriticalSection(&my_winsec);成对出现;可以多次进入
同一线程，lock() 同一个互斥量多次，报异常

// 线程6.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include<thread>
#include<iostream>
using namespace std;
#include<vector>
#include<list>
#include<mutex>
#include<Windows.h>

#define _WINDOWSJQ
class A {
public:
	//把收到的消息（玩家命令）写入到一个队列线程
	void inMsgRecvQueue()
	{
		for (int i = 0; i<10000; i++)
		{
			cout << "inMesRecvQueue()执行，插入元素" << i << endl;
#ifdef _WINDOWSJQ
			EnterCriticalSection(&my_winsec);//进入临界区
			msgRecvQueue.push_back(i);
			LeaveCriticalSection(&my_winsec);//离开临界区
#else
			my_mutex1.lock();
			msgRecvQueue.push_back(i); //假设数字为接受的命令，直接进入消息队
			my_mutex1.unlock();
			
#endif // _WINDOWSJQ		
		}
	}
	bool outMsgLULProc(int &command)
	{
#ifdef _WINDOWSJQ
		EnterCriticalSection(&my_winsec);
		if (!msgRecvQueue.empty())
		{
			//消息不为空
			command = msgRecvQueue.front();//返回第一个元素，但不检查元素是否存在
			msgRecvQueue.pop_front();//移除第一个元素，但不返回
			LeaveCriticalSection(&my_winsec);
			return true;
		}
		LeaveCriticalSection(&my_winsec);
		return false;
#else
		my_mutex1.lock();
		if (!msgRecvQueue.empty())
		{
			//消息不为空
			command = msgRecvQueue.front();//返回第一个元素，但不检查元素是否存在

			msgRecvQueue.pop_front();//移除第一个元素，但不返回
									 //这里是处理数据....
									 //cout << "处理数据" << command << endl;
			my_mutex1.unlock();
			return true;
		}
		my_mutex1.unlock();
		return false;
#endif
	}

	//把数据从消息队列中取出的线程
	void outMsgRecvQueue()
	{
		int command = 0;
		for (int i = 0; i<10000; i++)
		{

			bool result = outMsgLULProc(command);
			if (result)
				cout << "outMsgRecvQueue()函数处理数据，去除一个元素 =" << command << endl;
			else
			{
				//消息队列为空
				cout << "outMsgRecvQueue（）执行，但目前消息队列中为" << i << endl;
			}
		}
		cout << "消息队列处理完成" << endl;
	}

	A()
	{
#ifdef _WINDOWSJQ
		InitializeCriticalSection(&my_winsec);//初始化
#endif // _WINDOWSJQ

	}
private:
	list<int> msgRecvQueue;//容器，专门用于代表玩家发送过来的消息
	mutex my_mutex1;//创建互斥量
	mutex my_mutex2;//创建互斥量
	std::condition_variable my_cond;//生成一个条件变量对象
#ifdef  _WINDOWSJQ
	CRITICAL_SECTION my_winsec; //windows临界区
#endif //  _WINDOWSJQ

};
int main()
{
	A myobj;
	thread myOutMsgObj(&A::outMsgRecvQueue, &myobj);//第二个参数是引用  避免复制
	thread myOutMsgObj1(&A::outMsgRecvQueue, &myobj);
	thread myInMsgObj(&A::inMsgRecvQueue, &myobj);

	myOutMsgObj.join();
	myOutMsgObj1.join();
	myInMsgObj.join();

	cout << "主线程结束" << endl;
	return 0; 
}

2.自动析构技术
std::lock_guard
class CWinLock //叫RAII类 资源获取即初始化

// 线程6.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include<thread>
#include<iostream>
using namespace std;
#include<vector>
#include<list>
#include<mutex>
#include<Windows.h>

#define _WINDOWSJQ

//本类用于自动释放windows下的临界区，类似std::lock_gurad
class CWinLock   //叫RAII类  资源获取即初始化 
{
public:
	CWinLock(CRITICAL_SECTION *pCritmp)
	{
		m_pCritical = pCritmp;
		EnterCriticalSection(pCritmp);

	}
	~CWinLock()
	{
		LeaveCriticalSection(m_pCritical);
	}
private:
	CRITICAL_SECTION *m_pCritical;
};

class A {
public:
	//把收到的消息（玩家命令）写入到一个队列线程
	void inMsgRecvQueue()
	{
		for (int i = 0; i<10000; i++)
		{
			cout << "inMesRecvQueue()执行，插入元素" << i << endl;
#ifdef _WINDOWSJQ
			//EnterCriticalSection(&my_winsec);//进入临界区
			CWinLock as(&my_winsec);
			CWinLock as1(&my_winsec);  //多次进入，没问题
			msgRecvQueue.push_back(i);
			//LeaveCriticalSection(&my_winsec);//离开临界区
#else
			//my_mutex1.lock();
			std::lock_guard<std::mutex>obj1(my_mutex1);
			std::chrono::microseconds timeout(100);
			msgRecvQueue.push_back(i); //假设数字为接受的命令，直接进入消息队
			//my_mutex1.unlock();
			
#endif // _WINDOWSJQ		
		}
	}


	bool outMsgLULProc(int &command)
	{
#ifdef _WINDOWSJQ
		EnterCriticalSection(&my_winsec);
		if (!msgRecvQueue.empty())
		{
			//消息不为空
			command = msgRecvQueue.front();//返回第一个元素，但不检查元素是否存在
			msgRecvQueue.pop_front();//移除第一个元素，但不返回
			LeaveCriticalSection(&my_winsec);
			return true;
		}
		LeaveCriticalSection(&my_winsec);
		return false;
#else
		my_mutex1.lock();
		if (!msgRecvQueue.empty())
		{
			//消息不为空
			command = msgRecvQueue.front();//返回第一个元素，但不检查元素是否存在

			msgRecvQueue.pop_front();//移除第一个元素，但不返回
									 //这里是处理数据....
									 //cout << "处理数据" << command << endl;
			my_mutex1.unlock();
			return true;
		}
		my_mutex1.unlock();
		return false;
#endif
	}

	//把数据从消息队列中取出的线程
	void outMsgRecvQueue()
	{
		int command = 0;
		for (int i = 0; i<10000; i++)
		{

			bool result = outMsgLULProc(command);
			if (result)
				cout << "outMsgRecvQueue()函数处理数据，去除一个元素 =" << command << endl;
			else
			{
				//消息队列为空
				cout << "outMsgRecvQueue（）执行，但目前消息队列中为" << i << endl;
			}
		}
		cout << "消息队列处理完成" << endl;
	}

	A()
	{
#ifdef _WINDOWSJQ
		InitializeCriticalSection(&my_winsec);//初始化
#endif // _WINDOWSJQ

	}
private:
	list<int> msgRecvQueue;//容器，专门用于代表玩家发送过来的消息
	mutex my_mutex1;//创建互斥量
	mutex my_mutex2;//创建互斥量
	std::condition_variable my_cond;//生成一个条件变量对象
#ifdef  _WINDOWSJQ
	CRITICAL_SECTION my_winsec; //windows临界区
#endif //  _WINDOWSJQ

};
int main()
{
	A myobj;
	thread myOutMsgObj(&A::outMsgRecvQueue, &myobj);//第二个参数是引用  避免复制
	thread myOutMsgObj1(&A::outMsgRecvQueue, &myobj);
	thread myInMsgObj(&A::inMsgRecvQueue, &myobj);
	myOutMsgObj.join();
	myOutMsgObj1.join();
	myInMsgObj.join();
	cout << "主线程结束" << endl;
	return 0; 
}
  1. recursive_mutex 递归的独占互斥量,可以多次锁
    std::mutex 独占互斥量，自己lock时，别人lock不了
    recursive_mutex 递归的独占互斥量：允许同一个线程，同一个互斥量，多次被lock
    recursive_mutex 有lock也有unlock
// 线程6.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include<thread>
#include<iostream>
using namespace std;
#include<vector>
#include<list>
#include<mutex>
#include<Windows.h>

//#define _WINDOWSJQ

//本类用于自动释放windows下的临界区，类似std::lock_gurad
class CWinLock   //叫RAII类  资源获取即初始化 
{
public:
	CWinLock(CRITICAL_SECTION *pCritmp)
	{
		m_pCritical = pCritmp;
		EnterCriticalSection(pCritmp);

	}
	~CWinLock()
	{
		LeaveCriticalSection(m_pCritical);
	}
private:
	CRITICAL_SECTION *m_pCritical;
};

class A {
public:
	//把收到的消息（玩家命令）写入到一个队列线程
	void inMsgRecvQueue()
	{
		for (int i = 0; i<10000; i++)
		{
			cout << "inMesRecvQueue()执行，插入元素" << i << endl;
#ifdef _WINDOWSJQ
			//EnterCriticalSection(&my_winsec);//进入临界区
			CWinLock as(&my_winsec);
			CWinLock as1(&my_winsec);  //多次进入，没问题
			msgRecvQueue.push_back(i);
			//LeaveCriticalSection(&my_winsec);//离开临界区
#else
			//my_mutex1.lock();
			std::lock_guard<std::recursive_mutex>obj1(my_mutex1);
			testfuncl(); //加了三次锁
			msgRecvQueue.push_back(i); //假设数字为接受的命令，直接进入消息队
			//my_mutex1.unlock();
			
#endif // _WINDOWSJQ		
		}
	}


	bool outMsgLULProc(int &command)
	{
#ifdef _WINDOWSJQ
		EnterCriticalSection(&my_winsec);
		if (!msgRecvQueue.empty())
		{
			//消息不为空
			command = msgRecvQueue.front();//返回第一个元素，但不检查元素是否存在
			msgRecvQueue.pop_front();//移除第一个元素，但不返回
			LeaveCriticalSection(&my_winsec);
			return true;
		}
		LeaveCriticalSection(&my_winsec);
		return false;
#else
		//my_mutex1.lock();
		std::lock_guard<std::recursive_mutex>obj(my_mutex1);
		/*std::chrono::milliseconds sleeptime(10000000);
		std::this_thread::sleep_for(sleeptime);*/

		if (!msgRecvQueue.empty())
		{
			//消息不为空
			command = msgRecvQueue.front();//返回第一个元素，但不检查元素是否存在

			msgRecvQueue.pop_front();//移除第一个元素，但不返回
									 //这里是处理数据....
									 //cout << "处理数据" << command << endl;
			//my_mutex1.unlock();
			return true;
		}
		//my_mutex1.unlock();
		return false;
#endif
	}

	//把数据从消息队列中取出的线程
	void outMsgRecvQueue()
	{
		int command = 0;
		for (int i = 0; i<10000; i++)
		{

			bool result = outMsgLULProc(command);
			if (result)
				cout << "outMsgRecvQueue()函数处理数据，去除一个元素 =" << command << endl;
			else
			{
				//消息队列为空
				cout << "outMsgRecvQueue（）执行，但目前消息队列中为" << i << endl;
			}
		}
		cout << "消息队列处理完成" << endl;
	}

	A()
	{
#ifdef _WINDOWSJQ
		InitializeCriticalSection(&my_winsec);//初始化
#endif // _WINDOWSJQ

	}
	
	void testfuncl()
	{
		std::lock_guard<std::recursive_mutex>obj1(my_mutex1);
		testfuncl2();
	}
	void testfuncl2()
	{
		//std::lock_guard<std::recursive_mutex>obj1(my_mutex1);
		std::lock_guard<std::recursive_mutex>obj1(my_mutex1);
	}
private:
	list<int> msgRecvQueue;//容器，专门用于代表玩家发送过来的消息
	std::recursive_mutex my_mutex1; //创建递归互斥量
#ifdef  _WINDOWSJQ
	CRITICAL_SECTION my_winsec; //windows临界区
#endif //  _WINDOWSJQ

};
int main()
{
	A myobj;
	thread myOutMsgObj(&A::outMsgRecvQueue, &myobj);//第二个参数是引用  避免复制
	thread myOutMsgObj1(&A::outMsgRecvQueue, &myobj);
	thread myInMsgObj(&A::inMsgRecvQueue, &myobj);
	myOutMsgObj.join();
	myOutMsgObj1.join();
	myInMsgObj.join();
	cout << "主线程结束" << endl;
	return 0; 
}

4.带超时功能的独占互斥量 std::timed_mutex
try_lock_for() 等待一段时间
try_lock_unit() 参数时一个未来的时间点

带超时功能的递归独占互斥量 std::recursive_timed_mutex 允许同一个线程多次获取这个互斥量

// 线程6.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include<thread>
#include<iostream>
using namespace std;
#include<vector>
#include<list>
#include<mutex>
#include<Windows.h>

//#define _WINDOWSJQ

//本类用于自动释放windows下的临界区，类似std::lock_gurad
class CWinLock   //叫RAII类  资源获取即初始化 
{
public:
	CWinLock(CRITICAL_SECTION *pCritmp)
	{
		m_pCritical = pCritmp;
		EnterCriticalSection(pCritmp);

	}
	~CWinLock()
	{
		LeaveCriticalSection(m_pCritical);
	}
private:
	CRITICAL_SECTION *m_pCritical;
};

class A {
public:
	//把收到的消息（玩家命令）写入到一个队列线程
	void inMsgRecvQueue()
	{
		for (int i = 0; i<10000; i++)
		{
			cout << "inMesRecvQueue()执行，插入元素" << i << endl;
#ifdef _WINDOWSJQ
			//EnterCriticalSection(&my_winsec);//进入临界区
			CWinLock as(&my_winsec);
			CWinLock as1(&my_winsec);  //多次进入，没问题
			msgRecvQueue.push_back(i);
			//LeaveCriticalSection(&my_winsec);//离开临界区
#else
			//my_mutex1.lock();
			//std::lock_guard<std::recursive_mutex>obj1(my_mutex1);
			//std::lock_guard<std::mutex>obj1(my_mutex1);
			std::chrono::microseconds timeout(100);
			//if (my_mutex1.try_lock_for(timeout)) //等待100ms 来尝试获取锁
			if (my_mutex1.try_lock_until(std::chrono::steady_clock::now() + timeout))
			{
				msgRecvQueue.push_back(i);
				my_mutex1.unlock();
			}
			else
			{
				std::chrono::microseconds sleeptime(100);
				std::this_thread::sleep_for(sleeptime);
			}
			
#endif // _WINDOWSJQ		
		}
	}


	bool outMsgLULProc(int &command)
	{
#ifdef _WINDOWSJQ
		EnterCriticalSection(&my_winsec);
		if (!msgRecvQueue.empty())
		{
			//消息不为空
			command = msgRecvQueue.front();//返回第一个元素，但不检查元素是否存在
			msgRecvQueue.pop_front();//移除第一个元素，但不返回
			LeaveCriticalSection(&my_winsec);
			return true;
		}
		LeaveCriticalSection(&my_winsec);
		return false;
#else
		my_mutex1.lock();
		//std::lock_guard<std::recursive_mutex>obj(my_mutex1);
		//std::chrono::milliseconds sleeptime(10000);
		//std::this_thread::sleep_for(sleeptime);

		if (!msgRecvQueue.empty())
		{
			//消息不为空
			command = msgRecvQueue.front();//返回第一个元素，但不检查元素是否存在

			msgRecvQueue.pop_front();//移除第一个元素，但不返回
									 //这里是处理数据....
									 //cout << "处理数据" << command << endl;
			my_mutex1.unlock();
			return true;
		}
		my_mutex1.unlock();
		return false;
#endif
	}

	//把数据从消息队列中取出的线程
	void outMsgRecvQueue()
	{
		int command = 0;
		for (int i = 0; i<10000; i++)
		{

			bool result = outMsgLULProc(command);
			if (result)
				cout << "outMsgRecvQueue()函数处理数据，去除一个元素 =" << command << endl;
			else
			{
				//消息队列为空
				cout << "outMsgRecvQueue（）执行，但目前消息队列中为" << i << endl;
			}
		}
		cout << "消息队列处理完成" << endl;
	}

	A()
	{
#ifdef _WINDOWSJQ
		InitializeCriticalSection(&my_winsec);//初始化
#endif // _WINDOWSJQ

	}
	
private:
	list<int> msgRecvQueue;//容器，专门用于代表玩家发送过来的消息
	std::timed_mutex my_mutex1;//带超时功能的独占互斥量
#ifdef  _WINDOWSJQ
	CRITICAL_SECTION my_winsec; //windows临界区
#endif //  _WINDOWSJQ

};
int main()
{
	A myobj;
	thread myOutMsgObj(&A::outMsgRecvQueue, &myobj);//第二个参数是引用  避免复制
	thread myOutMsgObj1(&A::outMsgRecvQueue, &myobj);
	thread myInMsgObj(&A::inMsgRecvQueue, &myobj);

	myOutMsgObj.join();
	myOutMsgObj1.join();
	myInMsgObj.join();
	cout << "主线程结束" << endl;
	return 0; 
}
一生只爱何
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Windows下多线程编程示例
02-07
掌握Windows下多线程的实现，规避多线程带来的意外错误！
临界区和条件变量实现读写者问题
07-29
关于读写者问题的源码，其中，采用的方式是临界区和条件变量相结合。
Windows环境下多线程编程（C++）
qq_20853741的博客
02-25 711
多线程在编程中有相当重要的地位，我们在实际开发时或者找工作面试时总能遇到多线程的问题，对多线程的理解程度从一个侧面反映了程序员的编程水平。 　　其实C++语言本身并没有提供多线程机制（当然目前C++ 11新特性中，已经可以使用std::thread来创建线程了，因为还没有系统地了解过，所以这里不提了。），但Windows系统为我们提供了相关API，我们可以使用他们来进行多线程编程。 创建线程的API函数 HANDLE CreateThread( LPSECURITY_ATTRIBUT...
6.12 windows临界区、recursive_mutex递归的独占互斥量、超时互斥量std::timed_mutex、自动析构技术
qq_41543888的博客
10-10 356
Windows临界区与互斥量用法非常相似；但也有些差别 在“同一个线程”(不同线程中会卡住等待)中， Windows中的“相同临界区变量”代表的临界区的进入(EnterCriticalSection)可以被多次调用，但是调用了几次EnterCriticalSection(),就得调用几次EnterCriticalSection() 而在C++11中，std::mutex不允许同一个线程中l...
C++并发与多线程(十一)windows临界区、recursive_mutex、timed_mutex
Electro1ux的博客
02-02 415
windows临界区 windows临界区是在windows编程中的内容，了解一下即可，效果几乎可以等同于c++11的mutex；windows编程仅能在windows操作系统中使用，其它环境（例如linux）是不能正常运行的。 使用方法： //包含头文件 #include <Windows.h> CRITICAL_SECTION m_winsec; //windwos临界区定义 InitializeCriticalSection(&m_winsec); //windows临界区使用
Python多线程操作之互斥锁、递归锁、信号量、事件实例详解
09-17
递归锁是在互斥锁的基础上增加了一种特殊功能，允许同一个线程多次获取同一把锁，而不会导致死锁。这在某些需要嵌套锁的场景下非常有用。在Python中，我们使用`threading.RLock()`创建递归锁。与互斥锁不同，递归锁...
hannuota.rar_Hanoi_non-recursive_hannuota_汉诺塔_汉诺塔-递归算法_递归 非递归
09-22
这个问题通常用递归算法来解决，但在本例中，我们关注的是非递归的解决方案。 非递归的汉诺塔算法通常采用迭代的方式，利用栈或者队列等数据结构来模拟递归过程。下面我们将详细探讨这个主题： 1. **问题定义**：...
多任务编程超入门-（8） 递归互斥量
07-17
本篇主要介绍递归互斥量，这是C++和QT库中一个重要的同步原语，用于解决多线程间的互斥访问问题。递归互斥量允许同一线程在已经获取锁的情况下再次请求并获得该锁，而其他线程在该线程释放锁之前将被阻塞。 首先，...
C++11 并发指南之std::mutex详解
08-25
C++11 中的 std::mutex 是一种基本的互斥量，提供了独占所有权的特性，即不支持递归地对 std::mutex 对象上锁。std::mutex 对象提供了 lock()、unlock() 和 try_lock() 三种成员函数，分别用于锁住、解锁和尝试锁住...
digui.rar_recursive features_svm特征选择_特征选择 SVM_特征选择matlab_递归特征消除
07-14
在机器学习领域，特征选择是模型构建过程中至关重要的一环，因为它直接影响着模型的性能和解释性。本资源包“digui.rar”聚焦于一种特征选择方法——递归特征消除（Recursive Feature Elimination, RFE），并特别...
vc临界区的实现
07-12
用VC实现两个线程的同步,申请不当则可能会发会死锁.<br>此例就是如此
递归加锁std::recursive_mutex使用
hanhan的博客
06-12 502
c++标准库为此提供了std::recursive_mutex，其工作方式与mutex类似，不同的是，其允许同一线程对某互斥的同一个实例多次加锁。是一个递归互斥量，它允许同一个线程多次对它进行加锁操作，而不会导致死锁。最后，线程会输出一条信息表示线程已经释放了互斥量，并解锁。有些场景中，我们需要让线程在同一互斥上多次重复加锁，而无需解锁。，然后输出一条信息表示线程已经锁定了互斥量。时，需要注意避免死锁和竞争条件的问题。的值大于 1，线程会递归地调用。，它会递归地调用自己，直到。
c++11 std condition_variable_any和recursive_mutex配合使用例子
OneGit
09-15 950
#include &lt;iostream&gt; #include &lt;thread&gt; #include &lt;mutex&gt; #include &lt;condition_variable&gt; #include &lt;unistd.h&gt; using namespace std; //std::mutex mtx; std::recursive_mutex rmtx...
C++11 mutex方便的自解锁lock_guard
热门推荐
萧戈的专栏
01-06 1万+
 下面是cpprefrence里的使用mutex的代码。 #include #include #include #include #include #include std::map g_pages; std::mutex g_pages_mutex; void save_page(const std::string &url) { // si
深入理解critical_section
cffishappy的专栏
09-23 1345
转自：http://www.cnblogs.com/dirichlet/archive/2011/03/16/1986251.html   摘要 临界区是一种防止多个线程同时执行一个特定代码节的机制，这一主题并没有引起太多关注，因而人们未能对其深刻理解。在需要跟踪代码中
多线程实例代码 - 面向过程语言
majunzhu的博客
09-20 270
#include <iostream> #include <windows.h> using namespace std; DWORD WINAPI Fun(LPVOID lpParamter) { for (int i = 0; i < 10; i++) cout << "A Thread Fun Displa...
windows系统c++多线程开发
m0_37170593的博客
02-20 3349
线程的一些基本概念 一、线程的基本概念。 基本概念：线程，即轻量级进程（LWP:LightWeight Process），是程序执行流的最小单元。一个标准的线程由线程ID、当前指令指针（PC），寄存器集合和堆栈组成。线程是进程中的一个实体，是被系统独立调度和分派的基本单位。线程不拥有系统资源，近拥有少量运行必须的资源。 二、线程的基本状态。 基本状态：就绪、阻塞和运行三种基本状态。 就绪
recursive_mutex
最新发布
08-10
recursive_mutex是一个特殊的互斥锁，它允许同一个线程对它进行多次加锁。通常的互斥锁在同一个线程多次加锁时会导致死锁，因为它们假设每个线程只会对互斥锁进行一次加锁操作，而对于同一个线程的多次加锁操作，会...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值