【效率对比】c++多线程同步几种方式的效率对比研究： 原子操作，c++锁，自旋锁，windows临界区，windows互斥对象

最新推荐文章于 2024-06-13 10:48:47 发布
最新推荐文章于 2024-06-13 10:48:47 发布
阅读量2.8k 收藏 12
点赞数 5
分类专栏： C++ 编程 源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/carlclouder/article/details/104861333
版权
编程 同时被 3 个专栏收录
16 篇文章 0 订阅
订阅专栏
C++
9 篇文章 0 订阅
订阅专栏
源码
5 篇文章 0 订阅
订阅专栏

通过比较以下几种同步方式，测试各方法效率，分为以下6种情况做对比：

  1. 不加任何同步措施；
  2. Windows原子操作；
  3. c++11 mutrex；
  4. 自定义的自旋锁CLCS；
  5. Windows临界区；
  6. Windows互斥对象；

硬件平台：AMD 8核16线程，内存16GB
系统/软件平台：windows10，vs2019com(vc++)；
方法：定义3个变量，在多线程中自加（16线程x10万次），记录时间并考察结果正确性；

结果如下：
在这里插入图片描述
结论 ：

  1. 不加锁，速度极快，但结果是不可预测的错误值，没有应用价值。
  2. windows原子操作 及 c++11中的mutrex效率非常高；
    【让人不可思议的是，c++的mutrex锁的实现效率非常高，接近了原子操作的效率，这一点非常让人意外，一直以为c++锁会由于跨平台要求和底层调用封装，而会慢于windows临界区，看来这是不
    对的。通过查看mutrex在windows vc 上面的底层实现，发现原来是使用了windows7才加入 SRWLock锁（读写锁），也就是在windows vista及以前的windwos平台仍然使用的临界区，而windows7平台用SRWLock锁替代了，而进一步剖析SRWLock的底层实现，仍然是用的原子自旋锁，这也解释了为什么c++mutrex在win7及以上的平台效率和原子锁效率相同的原因】
  3. 自定义的自旋锁，速度可以实现得很精简，效率略高于Windows临界区的效率，毕竟摆脱了一些多余的调用过程；
  4. Windows临界区效率尚可，但仍然是原子操作和c++锁的所需时间的10倍以上；
  5. Windows互斥对象，由于实现跨进程同步，需要进入系统内核进行调度，所以比较慢，耗时是临界区的10倍以上；

以下是测试代码：
【 并行化支持】

int main() {	
	const size_t times = 100000;
	size_t a = 0, b = 0, c = 0;
	CLAtomic<size_t> aa = 0, ba = 0, ca = 0; //原子对象
	CLCS cs;
	CLCSLock cs2;
	TaskPoolStatic volatile as;
	CLTick tk; //高精度定时器
	tk.timingStart();
	parallel_proc([&](int ci, int n) {  //并行化
		for (size_t i = 0; i < times; i++)
		{
			++a; ++b; ++c;
		}
		});
	auto s0_ = tk.getSpendTime();
	cout << "\nno lock:       " << a << " , " << b << " , " << c << " , time = " << s0_ << " , error ...";
	tk.timingStart();
	parallel_proc([&](int ci, int n) {
		for (size_t i = 0; i < times; i++)
		{
			++aa;++ba;++ca;
		}
		});
	auto s0 = tk.getSpendTime();
	cout << "\nAtomic:        " << aa() << " , " << ba() << " , " << ca() << " , time = " << s0;
	a = 0, b = 0, c = 0;
	mutex cs3;
	tk.timingStart();
	parallel_proc([&](int ci, int n) {
		for (size_t i = 0; i < times; i++)
		{
			cs3.lock(); ++a; cs3.unlock();
			cs3.lock(); ++b; cs3.unlock();
			cs3.lock(); ++c; cs3.unlock();
		}
		});
	auto s4 = tk.getSpendTime();
	cout << "\nc++11 mutex:   " << a << " , " << b << " , " << c << " , time = " << s4;
	a = 0, b = 0, c = 0;
	tk.timingStart();
	parallel_proc([&](int ci, int n) {
		for (size_t i = 0; i < times; i++)
		{
			cs.lock(); ++a; cs.unlock();
			cs.lock(); ++b; cs.unlock();
			cs.lock(); ++c; cs.unlock();
		}
		});
	auto s1 = tk.getSpendTime();
	cout << "\nclcs:          " << a << " , " << b << " , " << c << " , time = " << s1;
	a = 0, b = 0, c = 0;
	tk.timingStart();
	parallel_proc([&](int ci, int n) {
		for (size_t i = 0; i < times; i++)
		{
			cs2.lock(); ++a; cs2.unlock();
			cs2.lock(); ++b; cs2.unlock();
			cs2.lock(); ++c; cs2.unlock();
		}
		});
	auto s2 = tk.getSpendTime();
	cout << "\nWindows cs:    " << a << " , " << b << " , " << c << " , time = " << s2;
	a = 0, b = 0, c = 0;
	HANDLE mt = CreateMutex(0, 0, 0);
	tk.timingStart();
	parallel_proc([&](int ci, int n) {
		for (size_t i = 0; i < times; i++)
		{
			if (WaitForSingleObject(mt, INFINITE) == WAIT_OBJECT_0) { ++a; ReleaseMutex(mt); }
			if (WaitForSingleObject(mt, INFINITE) == WAIT_OBJECT_0) { ++b; ReleaseMutex(mt); }
			if (WaitForSingleObject(mt, INFINITE) == WAIT_OBJECT_0) { ++c; ReleaseMutex(mt); }
		}
		});	
	auto s3 = tk.getSpendTime();
	CloseHandle(mt);
	cout << "\nWindows Mutex: " << a << " , " << b << " , " << c << " , time = " << s3;
	
	return 1;
	}

自旋锁定义：

#ifndef _CL_CS_H_
#define _CL_CS_H_
//自旋锁
typedef struct _cl_cs {
	LONG bLock = FALSE;
	DWORD ownerThreadId = 0;
	LONG lockCounts = 0;
	void enter() {
		auto cid = GetCurrentThreadId();
		if (ownerThreadId != cid) {
			while (InterlockedExchange(&bLock, TRUE) == TRUE);
			//Sleep(0);
			ownerThreadId = cid;
		}
		++lockCounts;
	}
	void leave() {
		auto cid = GetCurrentThreadId();
		if (cid != ownerThreadId)
			return;
		--lockCounts;
		if (lockCounts == 0) {
			ownerThreadId = 0;
			bLock = FALSE;
		}
	}
	inline void lock() { enter(); }
	inline void unlock() { leave(); }
}CLCS, * PCLCS;
#endif

原子模板类定义：

//原子操作类
#ifndef _CL_ATOMIC_H_
#define _CL_ATOMIC_H_
//默认状态下CLAtomic类对象的原子操作模式是否启动，原子操作在保证线程安全情况下将降低代码效率；
#define CLAtomic_bUseAtomc_def true

//原子操作类（模板）
template<class T>
class CLAtomic {	
protected:
	T Target;
	bool bUseAtomc;

	inline static bool atomicCAS(CHAR volatile* dest, CHAR newvalue, CHAR oldvalue)
	{
		SHORT cov = *reinterpret_cast<SHORT volatile*>(dest);cov &= 0xff00;
		SHORT new1 = newvalue;new1 |= cov;
		SHORT old = oldvalue;old |= cov;
		SHORT tem = InterlockedCompareExchange16(reinterpret_cast<SHORT volatile*>(dest),new1,old);
		return tem == old ? true : false;
	}
	inline static bool atomicCAS(UCHAR volatile* dest, UCHAR newvalue, UCHAR oldvalue)
	{
		return atomicCAS(reinterpret_cast<CHAR volatile*>(dest), CHAR(newvalue), CHAR(oldvalue));
	}
	inline static bool atomicCAS(SHORT volatile* dest, SHORT newvalue, SHORT oldvalue)
	{
		return InterlockedCompareExchange16(dest, newvalue, oldvalue) == oldvalue ? true : false;
	}
	inline static bool atomicCAS(USHORT volatile* dest, USHORT newvalue, USHORT oldvalue)
	{
		return atomicCAS(reinterpret_cast<SHORT volatile*>(dest), SHORT(newvalue), SHORT(oldvalue));
	}
	inline static bool atomicCAS(INT volatile* dest, INT newvalue, INT oldvalue)
	{
		return InterlockedCompareExchange((LONG volatile*)dest, (LONG)newvalue, (LONG)oldvalue) == (LONG)oldvalue ? true : false;
	}
	inline static bool atomicCAS(UINT volatile* dest, UINT newvalue, UINT oldvalue)
	{
		return atomicCAS(reinterpret_cast<INT volatile*>(dest), INT(newvalue), INT(oldvalue));
	}
	inline static bool atomicCAS(LONG volatile* dest, LONG newvalue, LONG oldvalue)
	{
		return InterlockedCompareExchange(dest, newvalue, oldvalue) == oldvalue ? true : false;
	}
	inline static bool atomicCAS(ULONG volatile* dest, ULONG newvalue, ULONG oldvalue)
	{
		return atomicCAS(reinterpret_cast<LONG volatile*>(dest), LONG(newvalue), LONG(oldvalue));
	}
	inline static bool atomicCAS(LONG64 volatile* dest, LONG64 newvalue, LONG64 oldvalue)
	{
		return InterlockedCompareExchange64(dest,newvalue,oldvalue) == oldvalue ? true : false;
	}
	inline static bool atomicCAS(ULONG64 volatile* dest, ULONG64 newvalue, ULONG64 oldvalue)
	{
		return atomicCAS(reinterpret_cast<LONG64 volatile*>(dest), LONG64(newvalue), LONG64(oldvalue));
	}
	inline static bool atomicCAS(FLOAT volatile* dest, FLOAT newvalue, FLOAT oldvalue)
	{
		//auto& new1 = *(LONG*)(void*)&newvalue;
		auto old1 = *(LONG*)(void*)&oldvalue;
		return InterlockedCompareExchange(
			reinterpret_cast<LONG volatile*>(dest),
			*(LONG*)(void*)&newvalue,
			old1) == old1 ? true : false;
	}
	inline static bool atomicCAS(DOUBLE volatile* dest, DOUBLE newvalue, DOUBLE oldvalue)
	{
		//auto& new1 = *(LONG64*)(void*)&newvalue;
		auto old1 = *(LONG64*)(void*)&oldvalue;
		return InterlockedCompareExchange64(
			reinterpret_cast<LONG64 volatile*>(dest),
			*(LONG64*)(void*)&newvalue,
			old1) == old1 ? true : false;
	}
	inline T increment()
	{
		T old;
		do {
			old = Target;
		} while (!CLAtomic::atomicCAS(&Target, old + T(1), old));
		return old;
	}
	inline T decrement()
	{
		T old;
		do {
			old = Target;
		} while (!CLAtomic::atomicCAS(&Target, old - T(1), old));
		return old;
	}
	inline T add(T v)
	{
		T old;
		do {
			old = Target;
		} while (!CLAtomic::atomicCAS(&Target, old + v, old));
		return old;
	}
	inline T mul(T v)
	{
		T old;
		do {
			old = Target;
		} while (!CLAtomic::atomicCAS(&Target, old * v, old));
		return old;
	}
	inline T div(T v)
	{
		T old;
		do {
			old = Target;
		} while (!CLAtomic::atomicCAS(&Target, old / v, old));
		return old;
	}
public:
	inline CLAtomic():bUseAtomc(CLAtomic_bUseAtomc_def){
	}
	inline CLAtomic(T v, bool _bUseAtomc = CLAtomic_bUseAtomc_def)
		:Target(v), bUseAtomc(_bUseAtomc) {
	}
	inline CLAtomic(const CLAtomic& v)
		:Target(v.Target), bUseAtomc(v.bUseAtomc) {
	}
	template<class T2>
	inline CLAtomic(const CLAtomic<T2>& v)
		:Target(v()), bUseAtomc(v.isUseAtomic()) {
	}
	CLAtomic& setUseAtomic(bool _bUseAtomc = CLAtomic_bUseAtomc_def) {
		return bUseAtomc = _bUseAtomc,*this;
	}
	bool isUseAtomic() const {
		return bUseAtomc;
	}
	template<class T2>
	inline CLAtomic& operator=(const T2 v2) {
		return Target = v2, *this;
	}
	template<class T2>
	inline CLAtomic& operator=(const CLAtomic<T2>& v2) {
		return Target = v2(), *this;
	}
	inline CLAtomic& operator=(const CLAtomic& v2) {
		return Target = v2.Target, *this;
	}
	inline CLAtomic& operator=(const T& v2) {
		return Target = v2, *this;
	}
	//默认为原子操作++()，当setUseAtomic(false)时采用非原子操作方式；
	inline CLAtomic& operator++() {
		return bUseAtomc ? increment() : ++Target, * this;
	}
	//默认为原子操作--()，当setUseAtomic(false)时采用非原子操作方式；
	inline CLAtomic& operator--() {
		return bUseAtomc ? decrement() : --Target, * this;
	}
	//默认为原子操作()++，当setUseAtomic(false)时采用非原子操作方式；
	inline T operator++(int) {
		if (bUseAtomc) {
			return increment();
		}
		else {
			T old = Target;  
			++Target;
			return old;
		}
	}
	//默认为原子操作()--，当setUseAtomic(false)时采用非原子操作方式；
	inline T operator--(int) {
		if (bUseAtomc) {
			return decrement();
		}
		else {
			T old = Target;  
			--Target;
			return old;
		}
	}
	//默认为原子操作+=，当setUseAtomic(false)时采用非原子操作方式；
	inline CLAtomic& operator+=(T v) {
		return  bUseAtomc ? add(v) : Target += v, * this;
	}
	//默认为原子操作-=，当setUseAtomic(false)时采用非原子操作方式；
	inline CLAtomic& operator-=(T v) {
		return  bUseAtomc ? add(0 - v) : Target -= v, * this;
	}
	//默认为原子操作*=，当setUseAtomic(false)时采用非原子操作方式；
	inline CLAtomic& operator*=(T v) {
		return  bUseAtomc ? mul(v) : Target *= v, * this;
	}
	//默认为原子操作/=，当setUseAtomic(false)时采用非原子操作方式；
	inline CLAtomic& operator/=(T v) {
		return  bUseAtomc ? div(v) : Target /= v, * this;
	}
	//默认为原子操作%=，当setUseAtomic(false)时采用非原子操作方式；
	inline  CLAtomic& operator%=(int v) {
		T old;
		do {
			old = Target;
		} while (!CLAtomic::atomicCAS(&Target, T(int(old) % v), old));
		return *this;
	}
	inline operator T() { return Target; }
	inline T operator()() const { return Target; }
	template<class T2> inline operator T2() const { return (T2)Target; }
	template<class T2> inline T operator+(const T2 v) const { return Target + v; }
	template<class T2> inline T operator-(const T2 v) const { return Target - v; }
	template<class T2> inline T operator*(const T2 v) const { return Target * v; }
	template<class T2> inline T operator/(const T2 v) const { return Target / v; }
	template<class T2> inline T operator%(const T2 v) const { return Target % (int)v; }
};

template<class T,class T2> inline T operator+(const T v,const CLAtomic<T2>& tag){ 
	return v + tag(); 
}
template<class T,class T2> inline T operator-(const T v,const CLAtomic<T2>& tag){ 
	return v - tag(); 
}
template<class T,class T2> inline T operator*(const T v,const CLAtomic<T2>& tag){ 
	return v * tag(); 
}
template<class T,class T2> inline T operator/(const T v,const CLAtomic<T2>& tag){ 
	return v / tag(); 
}
template<class T,class T2> inline T operator%(const T v,const CLAtomic<T2>& tag){ 
	return v % (int)tag(); 
}
#endif

计时器定义：

#ifndef __CL_TICK_DEF__
#define __CL_TICK_DEF__
 //高精度计时器类
 class CLTick {
 protected:
	 LARGE_INTEGER lis;
	 LARGE_INTEGER lie;
	 LARGE_INTEGER Freg;
 public:
	 CLTick() { 
		 timingStart();
	 }
	 //开始计时
	 CLTick& timingStart() {
		 QueryPerformanceFrequency(&Freg);
		 QueryPerformanceCounter(&lis);
		 return *this;
	 }
	 //取得从计时开始到当前的时间
	 double getSpendTime(bool saveToStart = false) {
		 QueryPerformanceCounter(&lie);
		 double rt = double(lie.QuadPart - lis.QuadPart) / double(Freg.QuadPart);
		 if (saveToStart)lis = lie;
		 return rt;
	 }
 };
#endif
夜雨清狂
关注
  • 5
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++ 中锁与原子操作的差异分析
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
06-28 975
在现代多线程编程中，确保数据的一致性和线程的协调运行是至关重要的。C++为此提供了两种主要的同步机制：锁和原子操作。这两种机制在内存管理、执行效率和编程模式上有着本质的不同，但它们的共同目标是保证线程之间的正确数据共享和操作顺序。
C++多线程之旅实战-自旋锁那点事
或许没有的博客
07-07 817
目录前言实现优缺点缺点优点适用场景Ticket LockCLH LockMCS Lock总结 前言 前一篇文章讲的是带锁的并发数据结构，而且讲到了如果不带锁将会面临什么样的问题。这一部分我将为大家带来一个全新的数据结构-自旋锁。这是一种不使用阻塞库的数据结构，我们将不使用阻塞库的结构称为非阻塞，但是不是所有的非阻塞数据结构都是无锁的。 阻塞函数就是当这个函数不执行完，函数所在线程就一直停止在这里不动。 比如最常见的在多线程里面的thread库基本上都是阻塞函数。 实现 自旋锁（spinlock）：是指当一个
C++多线程同步效率对比之临界区和原子锁
热门推荐
bodybo的专栏
10-21 1万+
多线程编程经常遇到数据同步问题，通常的做法就是
C++ 线程同步---临界区&自旋锁
qq_44802912的博客
08-17 467
一、概念 临界区又称关键代码段，指的是一小段代码在执行前，需要独占一些资源。程序中通常将多线程同时访问的某个资源作为临界区，需要定义一个CRITICAL_SECTION类型的变量，然后调用InitializeCriticalSection的函数对变量进行初始化，只能用于单进程。临界区是非内核对象，只在用户态进行锁操作，速度快；互斥体是内核对象，在核心态进行锁操作，速度慢。 目的：防止数据一致性被破坏。 函数声明： //初始化CRITICAL_SECTION变量 //lpCriticalSection：一个
C++线程同步几种方法
最新发布
yy_xzz的博客
06-13 489
在C++中，线程同步是确保多个线程在访问共享资源时能够协调一致的重要概念。
C++11线程中的几种锁
GoodLinGL的博客
04-26 7787
线程之间的锁有：互斥锁、条件锁、自旋锁、读写锁、递归锁。一般而言，锁的功能与性能成反比。不过我们一般不使用递归锁（C++标准库提供了std::recursive_mutex），所以这里就不推荐了。 互斥锁（Mutex） ...
【C++】linux 下 pthread 线程同步例子；实现互斥锁、自旋锁、读写锁、条件变量；
多丰富下自己呀
07-09 562
目录一、线程同步方法：1、互斥量 互斥锁（mutex）2、自旋锁（spin_lock）3、读写锁4、条件变量二、线程同步方法比较三、线程同步实例1、互斥锁2、自旋锁3、读写锁4、条件变量 一、线程同步方法： 1、互斥量 互斥锁（mutex） 互斥量保证先后执行； 互斥量保证了关键指令的原子性； （一系列操作不可被中断的特性；要么全部执行，要么全部没执行） 互斥量是线程同步的最简单的方法； 互斥量、互斥锁，他是处于两态之一的变量：解锁、加锁； 两个状态可以保证资源访问的串行性； 2、自旋锁（spin_lo
多线程同步，互斥体，信号量和自旋锁,原子操作CAS和显示锁
sun007700的专栏
12-28 448
互斥体，信号量和自旋锁 https://www.cnblogs.com/biyeymyhjob/archive/2012/07/21/2602015.html 互斥体与信号量的对比 https://blog.csdn.net/zwx19961130/article/details/78705041 自旋锁适用情况 自旋锁比较适用于锁使用者保持锁时间比较短的情况。正是由于自旋锁使用者.........
一文看懂临界区、互斥锁、同步锁、临界区、信号量、自旋锁等名词！
xmt1139057136的专栏
02-20 5260
点击上方“业余草”，选择“置顶公众号” 第一时间获取技术干货和业界资讯！ 关于线程安全的专有名词有一大堆。你们突然之间问我这个名词是什么意思，那个名词是什么意思我还真不一定能给你准确的回答。这还别说一门语言一堆名词。其实有些名词叫法不同，实际上就是一个意思。 A 语言有这个名词，B 语言就起另外一个名词。不能大胆的雷同，所以就改变一个叫法，其本质还是一样的。 为了减少大家在...
用c++ 11编写的有界多生产者多消费者并发队列- rigtorp/MPMCQueue
01-27
其中，原子操作保证了在多线程环境下对变量的读写操作不会引发数据竞争，互斥量用于保护临界区，确保同一时刻只有一个线程访问。 三、rigtorp/MPMCQueue设计 rigtorp/MPMCQueue库是一个C++11头文件库，实现了基于...
超级简单的程序锁.........
02-05
在IT领域，程序锁是一种常见的技术手段，用于保护软件资源，确保在多线程或并发环境中数据的一致性和完整性。标题“超级简单的程序锁”暗示我们讨论的是一个轻量级的解决方案，它体积小巧，但功能实用。描述中的反复...
cpp-锁的全栈工程师之路fighting
08-16
"cpp-锁的全栈工程师之路fighting"这个标题暗示了学习和理解锁在多线程编程中的重要性，以及如何通过深入研究来提升自己的技能。在C++中，处理并发和多线程问题时，锁是确保数据同步和安全的关键工具。 一、锁的...
C++（STL）容器采用迭代器访问及下标访问的效率详细对比，附详细代码及测试结果。
carlclouder的博客
10-06 5791
C++（STL）容器处理大量数据时的遍历操作，代码效率情况如何，今天做一个系统的效能测试，对比写不同的代码书写方法对效率的影响。值得注意的是，容器遍历这种底层操作，往往对上层高度封装后的代码效率在几何累计效应之下会产生巨大影响，不可忽视。 我们选用最简单的vector容器作为测试目标。先看下测试代码： void main() { vector<byte> tagv; ...
轻量级C++神经网络应用库CreativeLus：1、库介绍。案例：简单sin函数逼近。
carlclouder的博客
01-30 2440
CreativeLus库，又名“创造性逻辑元”，简称CL，是基于反馈式神经网络（BP网络）模型理论基础开发的C++神经网络库。希望在尽可能的丰富功能前提下，让使用者付出极低的代价。尤其是学生、研究人员或小型应用，在机器学习，深度学习，神经网络应用等领域能有一种快速的应用可选方案。 作为超轻量级应用库，它区别于TensorFlow、PyTorch等强大而复杂的系统工具或库，但它同样简单易用，而且有效。能处理常规逼近，分类问题，还能构建自定义的各类网络模型，包括：复杂节点网络，卷积网络(cnn)，残差网络
效率对比：分别用 C++Amp，C++ PPL，SSE/AVX，Serial（串行）计算矩阵乘法。
carlclouder的博客
02-12 2099
本次测试矩阵乘法未作分块优化。 未使用cuda测试。 采用微妙级的计时器。 分别对16阶方矩阵到4048阶方阵采用如下方式做乘法计算，统计结果。 C++Amp（GPU）， C++PPL（多线程16核）， SSE/AVX（单线程）， AVX-Db（单线程，双精度）， Serial（单线程串行） 时间统计如下（单位：秒） Rank : 16 32 64 128 256 512 10...
详细介绍多线程加锁有三种方式：互斥锁、读写锁和自旋锁。
04-08
好的，我可以回答这个问题。多线程加锁通常有三种方式：互斥锁、读写锁和自旋锁。互斥锁是一种最常用的锁，它可以确保同一时间只有一个线程可以访问共享资源。读写锁则可以允许多个线程同时读取共享资源，但是只允许一个线程进行写操作。自旋锁则是一种特殊的锁，它会在线程需要访问共享资源时进行忙等待，直到锁被释放为止。这三种锁的应用场景不同，需要根据实际情况选择合适的锁来保证程序的正确性和效率。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值