17.5 互斥量的概念、用法、死锁演示与解决详解

已于 2022-06-12 09:14:33 修改
阅读量319 收藏 2
点赞数 1
分类专栏： c++学习 文章标签： c++
于 2022-06-10 20:37:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzyzxb/article/details/125227799
版权

保护共享数据，操作时，某个线程，用代码把共享数据锁住，操作数据，解锁
其他操作共享数据的线程必须等待解锁。锁定住，操作，解锁。

一、互斥量(mutex)的基本概念

互斥量是个类对象，理解成一把锁，多个线程尝试用 lock() 成员函数来加锁这把锁头，只有一个线程能锁定成功(成功的标注是lock函数返回)。
如果没有锁成功，那么流程卡在 lock() 这里不断的尝试去锁这把锁头。
互斥量使用要小心，保护数据不能多也不能少，少了没有达到保护效果，多了影响效率。

二、互斥量的用法

<1>lock()、unlock()
先 lock() 操作共享数据，再 unlock()
lock() 和 unlock() 要成对使用，有 lock() 必然要有 unlock()，每调用一次 lock()，必然应该调用一次unlock()。
不应该也不允许调用1次 lock() 却调用了2次 unlock()，也不允许调用2次 lock() 却调用1次 unlock()，
这些非对称数量的调用都会导致代码不稳定甚至崩溃。

class MA
{
public:
	//把收到的消息(玩家命令)放入到一个队列的线程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			cout << "inMsgRecvQueue()执行，插入一个元素： " << i << endl;
			my_mutex.lock();
			msgRecvQueue.push_back(i);  //假设这个数字i就是我收到的命令，直接弄到消息队列中
			my_mutex.unlock();
		}
	}

	bool outMsgLUProc(int& command)
	{
		my_mutex.lock();
		if (!msgRecvQueue.empty())
		{
			//消息不为空
			command = msgRecvQueue.front();  //返回第一个元素，但不检查元素是否存在；
			msgRecvQueue.pop_front();  //移除第一个元素，但不返回
			my_mutex.unlock();
			return true;
		}
		my_mutex.unlock();
		return false;
	}

	//把数据从消息队列中取出的线程
	void outMsgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			if (!msgRecvQueue.empty())
			{
				outMsgLUProc(i);
				//这里就考虑处理数据...
				//...
			}
			else
			{
				//消息队列为空
				cout << "outMsgRecvQueue()执行，但目前消息队列中为空 " << i << endl;
			}
		}
		cout << "end" << endl;
	}
private:
	list<int> msgRecvQueue;  //容器(消息队列)，专门用于代表玩家发送的命令
	std::mutex my_mutex;  //创建了一个互斥量
};

int main()
{
	MA myobj;
	std::thread myOutMsgObj(&MA::outMsgRecvQueue, &myobj);  //第二个参数是引用,才能保证线程里用的是同一个对象
	std::thread myInMsgObj(&MA::inMsgRecvQueue, &myobj);
	myOutMsgObj.join();
	myInMsgObj.join();
	cout << "main主函数执行结束" << endl;  //最后执行这句，整个进程退出
	return 0;
}

有 lock()，忘记 unlock() 的问题，非常难排查；
为了防止大家忘记 unlock()，引入一个叫 std::lock_guard 的类模板：你忘记 unlock() 不要紧，我替你unlock()；
学习过智能指针(unique_ptr<>)：你忘记释放内存不要紧，我给你释放； 保姆

<2>std::lock_guard类模板：直接取代 lock() 和 unlock()，也就是说，你用了 lock_gurad 之后，再不能使用 lock() 和 unlock()。

class MA
{
public:
	//把收到的消息(玩家命令)放入到一个队列的线程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			cout << "inMsgRecvQueue()执行，插入一个元素： " << i << endl;
			{
				lock_guard<std::mutex> sbguard(my_mutex);
				msgRecvQueue.push_back(i);  //假设这个数字i就是我收到的命令，直接弄到消息队列中
			}
		}
	}

	bool outMsgLUProc(int& command)
	{
		lock_guard<std::mutex> sbguard(my_mutex);  //sbguard是随便起的对象名
		//lock_guard构造函数里执行了mutex::lock();
		//lock_guard析构函数里执行了mutex::unlock();
		if (!msgRecvQueue.empty())
		{
			//消息不为空
			command = msgRecvQueue.front();  //返回第一个元素，但不检查元素是否存在；
			msgRecvQueue.pop_front();  //移除第一个元素，但不返回
			return true;
		}
		return false;
	}

	//把数据从消息队列中取出的线程
	void outMsgRecvQueue()
	{
		int command = 0;
		for (int i = 0; i < 100000; ++i)
		{
			bool result = outMsgLUProc(command);
			if (result == true)
			{
				cout << "outMsgRecvQueue()执行，取出一个元素" << endl;
				//这里就考虑处理数据...
				//...
			}
			else
			{
				cout << "outMsgRecvQueue()执行，但目前消息队列中为空 " << i << endl;
			}
		}
		cout << "end" << endl;
	}
private:
	list<int> msgRecvQueue;  //容器(消息队列)，专门用于代表玩家发送的命令
	std::mutex my_mutex;  //创建了一个互斥量
};

int main()
{
	MA myobj;
	std::thread myOutMsgObj(&MA::outMsgRecvQueue, &myobj);  //第二个参数是引用,才能保证线程里用的是同一个对象
	std::thread myInMsgObj(&MA::inMsgRecvQueue, &myobj);
	myOutMsgObj.join();
	myInMsgObj.join();
	cout << "main主函数执行结束" << endl;  //最后执行这句，整个进程退出
	return 0;
}

三、死锁

张三：站在北京等李四 不挪窝
李四：站在深圳等张三 不挪窝
C++中，比如我有两把锁(死锁这个问题是由至少两个锁头也就是两个互斥量才能产生)，金锁(JinLock)，银锁(YinLock);
两个线程A，B

1>线程A执行的时候，这个线程先锁金锁，把金锁lock()成功后，然后它去lock()银锁…
出现上下文切换
2>线程B执行了，这个线程先锁银锁，因为银锁还没有被锁，所以银锁会lock()成功，线程B要去lock()金锁…
此时此刻，死锁就产生了
3>线程A因为拿不到银锁，流程走不下去(所有后边代码有解锁金锁的但是流程走不下去，所以金锁解不开)
4>线程B因为拿不到金锁，流程走不下去(所有后边代码有解锁银锁的但是流程走不下去，所以银锁解不开)
大家都晾在这里，你等我，我等你

<1>死锁演示

class MA
{
public:
	//把收到的消息(玩家命令)放入到一个队列的线程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			cout << "inMsgRecvQueue()执行，插入一个元素： " << i << endl;
			{
				my_mutex_1.lock();  //实际工程这两个锁头不一定挨着，可能他们需要保护不同的数据共享块
				my_mutex_2.lock();
				msgRecvQueue.push_back(i);  //假设这个数字i就是我收到的命令，直接弄到消息队列中
				my_mutex_2.unlock();
				my_mutex_1.unlock();
			}
		}
	}

	bool outMsgLUProc(int& command)
	{
		my_mutex_2.lock();
		my_mutex_1.lock();
		if (!msgRecvQueue.empty())
		{
			//消息不为空
			command = msgRecvQueue.front();  //返回第一个元素，但不检查元素是否存在；
			msgRecvQueue.pop_front();  //移除第一个元素，但不返回
			my_mutex_1.unlock();
			my_mutex_2.unlock();
			return true;
		}
		my_mutex_1.unlock();
		my_mutex_2.unlock();
		return false;
	}

	//把数据从消息队列中取出的线程
	void outMsgRecvQueue()
	{
		int command = 0;
		for (int i = 0; i < 100000; ++i)
		{
			bool result = outMsgLUProc(command);
			if (result == true)
			{
				cout << "outMsgRecvQueue()执行，取出一个元素" << endl;
				//这里就考虑处理数据...
				//...
			}
			else
			{
				cout << "outMsgRecvQueue()执行，但目前消息队列中为空 " << i << endl;
			}
		}
		cout << "end" << endl;
	}
private:
	list<int> msgRecvQueue;  //容器(消息队列)，专门用于代表玩家发送的命令
	mutex my_mutex_1;  //创建了一个互斥量  (一把锁头)
	mutex my_mutex_2;  //创建了一个互斥量
};

int main()
{
	MA myobj;
	std::thread myOutMsgObj(&MA::outMsgRecvQueue, &myobj);  //第二个参数是引用,才能保证线程里用的是同一个对象
	std::thread myInMsgObj(&MA::inMsgRecvQueue, &myobj);
	myOutMsgObj.join();
	myInMsgObj.join();
	cout << "main主函数执行结束" << endl;  //最后执行这句，整个进程退出
	return 0;
}

<2>死锁的一般解决方案
只要保证这两个互斥量上锁的顺序一致就不会死锁

class MA
{
public:
	//把收到的消息(玩家命令)放入到一个队列的线程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			cout << "inMsgRecvQueue()执行，插入一个元素： " << i << endl;
			{
				std::lock_guard<std::mutex> guard_1(my_mutex_1);
				std::lock_guard<std::mutex> guard_2(my_mutex_2);
				msgRecvQueue.push_back(i);  //假设这个数字i就是我收到的命令，直接弄到消息队列中
			}
		}
	}

	bool outMsgLUProc(int& command)
	{
		std::lock_guard<std::mutex> guard1(my_mutex_1);
		std::lock_guard<std::mutex> guard2(my_mutex_2);
		if (!msgRecvQueue.empty())
		{
			//消息不为空
			command = msgRecvQueue.front();  //返回第一个元素，但不检查元素是否存在；
			msgRecvQueue.pop_front();  //移除第一个元素，但不返回
			return true;
		}
		return false;
	}

	//把数据从消息队列中取出的线程
	void outMsgRecvQueue()
	{
		int command = 0;
		for (int i = 0; i < 100000; ++i)
		{
			bool result = outMsgLUProc(command);
			if (result == true)
			{
				cout << "outMsgRecvQueue()执行，取出一个元素" << endl;
				//这里就考虑处理数据...
				//...
			}
			else
			{
				cout << "outMsgRecvQueue()执行，但目前消息队列中为空 " << i << endl;
			}
		}
		cout << "end" << endl;
	}
		cout << "end" << endl;
	}
private:
	list<int> msgRecvQueue;  //容器(消息队列)，专门用于代表玩家发送的命令
	mutex my_mutex_1;  //创建了一个互斥量  (一把锁头)
	mutex my_mutex_2;  //创建了一个互斥量
};

int main()
{
	MA myobj;
	std::thread myOutMsgObj(&MA::outMsgRecvQueue, &myobj);  //第二个参数是引用,才能保证线程里用的是同一个对象
	std::thread myInMsgObj(&MA::inMsgRecvQueue, &myobj);
	myOutMsgObj.join();
	myInMsgObj.join();
	cout << "main主函数执行结束" << endl;  //最后执行这句，整个进程退出
	return 0;
}

<3>std::lock()函数模板：用来处理多个互斥量的时候才出场
能力：一次锁住两个或者两个以上的互斥量 (至少2个，多了不限，1个不行)。
它不存这种因为在多个线程中，因为锁的顺序问题导致死锁的风险。
std::lock()：如果互斥量中有一个没锁住，它就在那里等着，等所有互斥量都锁住，它才能往下走(返回)。
要么两个互斥量都锁住，要么两个互斥量都没锁住。如果只锁了一个，另外一个没锁成功，则它立即把已经锁住的解锁。

class MA
{
public:
	//把收到的消息(玩家命令)放入到一个队列的线程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			cout << "inMsgRecvQueue()执行，插入一个元素： " << i << endl;
			{
				std::lock(my_mutex_1, my_mutex_2);  //相当于每个互斥量都调用了lock()
				msgRecvQueue.push_back(i);  //假设这个数字i就是我收到的命令，直接弄到消息队列中
				my_mutex_2.unlock();
				my_mutex_1.unlock();
			}
		}
	}

	bool outMsgLUProc(int& command)
	{
		std::lock(my_mutex_2, my_mutex_1);
		if (!msgRecvQueue.empty())
		{
			//消息不为空
			command = msgRecvQueue.front();  //返回第一个元素，但不检查元素是否存在；
			msgRecvQueue.pop_front();  //移除第一个元素，但不返回
			my_mutex_1.unlock();
			my_mutex_2.unlock();
			return true;
		}
		my_mutex_1.unlock();
		my_mutex_2.unlock();
		return false;
	}

	//把数据从消息队列中取出的线程
	void outMsgRecvQueue()
	{
		int command = 0;
		for (int i = 0; i < 100000; ++i)
		{
			bool result = outMsgLUProc(command);
			if (result == true)
			{
				cout << "outMsgRecvQueue()执行，取出一个元素" << endl;
				//这里就考虑处理数据...
				//...
			}
			else
			{
				cout << "outMsgRecvQueue()执行，但目前消息队列中为空 " << i << endl;
			}
		}
		cout << "end" << endl;
	}
private:
	list<int> msgRecvQueue;  //容器(消息队列)，专门用于代表玩家发送的命令
	mutex my_mutex_1;  //创建了一个互斥量  (一把锁头)
	mutex my_mutex_2;  //创建了一个互斥量
};

int main()
{
	MA myobj;
	std::thread myOutMsgObj(&MA::outMsgRecvQueue, &myobj);  //第二个参数是引用,才能保证线程里用的是同一个对象
	std::thread myInMsgObj(&MA::inMsgRecvQueue, &myobj);
	myOutMsgObj.join();
	myInMsgObj.join();
	cout << "main主函数执行结束" << endl;  //最后执行这句，整个进程退出
	return 0;
}

<4>std::lock_guard的std::lock参数
std::adopt_lock是个结构体对象，起一个标记作用，作用就是表示这个互斥量已经lock()；
不需要在std::lock_guardstd::mutex构造函数里面再对mutex对象进行lock()了。

class MA
{
public:
	//把收到的消息(玩家命令)放入到一个队列的线程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			cout << "inMsgRecvQueue()执行，插入一个元素： " << i << endl;
			{
				std::lock(my_mutex_1, my_mutex_2);  //相当于每个互斥量都调用了lock()
				std::lock_guard<std::mutex> guard_1(my_mutex_1, std::adopt_lock);
				std::lock_guard<std::mutex> guard_2(my_mutex_2, std::adopt_lock);
				msgRecvQueue.push_back(i);  //假设这个数字i就是我收到的命令，直接弄到消息队列中
			}
		}
	}

	bool outMsgLUProc(int& command)
	{
		std::lock(my_mutex_2, my_mutex_1);
		std::lock_guard<std::mutex> guard1(my_mutex_2, std::adopt_lock);
		std::lock_guard<std::mutex> guard2(my_mutex_1, std::adopt_lock);
		if (!msgRecvQueue.empty())
		{
			//消息不为空
			command = msgRecvQueue.front();  //返回第一个元素，但不检查元素是否存在；
			msgRecvQueue.pop_front();  //移除第一个元素，但不返回
			return true;
		}
		return false;
	}

	//把数据从消息队列中取出的线程
	void outMsgRecvQueue()
	{
		int command = 0;
		for (int i = 0; i < 100000; ++i)
		{
			bool result = outMsgLUProc(command);
			if (result == true)
			{
				cout << "outMsgRecvQueue()执行，取出一个元素" << endl;
				//这里就考虑处理数据...
				//...
			}
			else
			{
				cout << "outMsgRecvQueue()执行，但目前消息队列中为空 " << i << endl;
			}
		}
		cout << "end" << endl;
	}
private:
	list<int> msgRecvQueue;  //容器(消息队列)，专门用于代表玩家发送的命令
	mutex my_mutex_1;  //创建了一个互斥量  (一把锁头)
	mutex my_mutex_2;  //创建了一个互斥量
};

int main()
{
	MA myobj;
	std::thread myOutMsgObj(&MA::outMsgRecvQueue, &myobj);  //第二个参数是引用,才能保证线程里用的是同一个对象
	std::thread myInMsgObj(&MA::inMsgRecvQueue, &myobj);
	myOutMsgObj.join();
	myInMsgObj.join();
	cout << "main主函数执行结束" << endl;  //最后执行这句，整个进程退出
	return 0;
}

总结：std::lock()：一次锁定多个互斥量，谨慎使用(建议一个一个锁)。

zzyzxb
关注
专栏目录
windows互斥量的使用
MY博客
02-18 713
windows互斥量的使用
互斥量概念、用法、死锁演示及解决详解
Scarlett的博客
02-21 968
保护共享数据，操作时，某个线程 用代码把共享数据锁住、操作数据、解锁；其他想操作共享数据的线程必须等待解锁，锁定住，操作，解锁 一、互斥量（mutex）的基本概念 互斥量就是个类对象，可以理解为一把锁，多个线程尝试用lock()成员函数来加锁，只有一个线程能锁定成功（成功的标志是lock()函数返回），如果没有锁成功，那么流程将卡在lock()这里不断尝试去锁定。 互斥量使用要小心，保护数据不多也不少，少了达不到效果，多了影响效率。 二、互斥量的用法 包含mutex 头文件（好像也可以不加） 2.1 loc
互斥量和死锁
沉默的帮凶
02-26 273
    1、互斥量可以理解为一把锁，在访问共享资源的时候，通过加锁，来确保在同一时间只有一个线程可以访问该共享资源。这里主要总结一下Linux下锁的使用，并通过锁的使用来进一步加深对互斥量的理解。    2、通过具体实例来说明用法：#include&lt;stdio.h&gt; #include&lt;pthread.h&gt; #include&lt;unistd.h&gt; pthread_...
FreeRTOS——互斥量篇
最新发布
顺顺崽的博客
07-10 849
互斥量（Mutex）是一种同步机制，用于在并发编程环境中保护共享资源，确保在任意时间只有一个任务能够访问该资源。它的名称来源于“互斥”，意即互斥量可以互相排斥，以防止资源被多个任务同时访问，从而避免数据竞争和不一致性问题。
C++11多线程---互斥量与死锁
weixin_44235615的博客
07-07 1037
C++11多线程---互斥量与死锁
互斥量
taifyang的博客
02-28 119
两个线程访问同一块共享资源，如果不协调顺序，容易造成数据混乱 加锁 mutex pthread_mutex_init 初始化 pthread_mutex_destroy 摧毁 pthread_mutex_lock 加锁 pthread_mutex_unlock(pthread_mutex_t *mutex) 解锁 互斥量的使用步骤：初始化、加锁、执行逻辑–共享操作数据、解锁 注意事项：加锁需要最小粒度，不要一直占用临界区 尝试加锁 pthread_mutex_trylock(pthread_mutex_t
Linux - 线程互斥
J4Ya_的博客
06-24 326
互斥量(mutex)很多变量需要在线程间共享,这个变量就称为共享变量,可以通过共享数据完成线程之间的交互.但是,多个线程并发的操作共享变量就会出现问题.如下模拟实现一个网上购票系统:#include &lt;stdio.h&gt;#include &lt;stdlib.h&gt;#include &lt;unistd.h&gt;#include &lt;pthread.h&gt;int ticke...
Java 解决死锁的方法实例详解
08-30
死锁的产生有四个必要条件：互斥使用、不可抢占、请求和保持以及循环等待。理解这些条件有助于避免和解决死锁。 1. **互斥使用**：资源在任何时候只能被一个线程占用，其他线程必须等待该资源被释放。 2. **不可...
Linux线程管理必备:解析互斥量与条件变量的详解
01-20
在Linux系统中，线程管理是程序设计的关键部分，特别是在多任务环境中，为了确保程序的稳定性和高效性，程序员常使用互斥量和条件变量来控制线程的并发执行。互斥量是一种同步机制，用于保护共享资源免受并发访问，...
Th5：互斥量概念、用法、死锁演示以及解决详解（很重要）
weixin_44980842的博客
12-22 1010
保护共享数据，操作时，某个线程用代码把共享数据锁住、操作数据、解锁。那么其他想操作共享数据的线程就必须等待锁住的线程解锁才能对共享数据进行操作。 《1》互斥量（mutex）的基本概念 互斥量（mutex）：互斥量是个类对象。我们可以理解为一把锁，多个线程都尝试用lock()成员函数来加锁这把锁头，但是只有一个线程会成功锁住（成功的标志是lock()函数成功返回）。如果某个线程卡在lock()这里，那么程序就会不断地尝试去锁住这把锁头（因为锁不上呀，所以就会一直卡在这儿...
C++并发与多线程编程--互斥量用法
locahuang的博客
07-23 189
1、互斥量概念 互斥量是个类对象。 理解成一把锁，多个线程尝试使用lock()成员函数来加锁，只有一个线程能锁定成功。 如果没有锁定成功，那么流程卡在lock()这里不断的尝试去锁住这把锁头。 互斥量使用要小心，保护数据不多也不少，少了，没达到保护的效果，多了，影响效率。 2、互斥量用法 （1）lock()，unlock() lock() 和unlock()要成对使用，有lock()，必然有unlock()。 不应该也不允许调用了一次lock()，却调用多次unlock()。 std::mutex ..
8.互斥量的使用--mutex
雨田2017的博客
06-13 1306
1.举例理解互斥锁 停车场（只有一个停车位）----------------        car1----------------car1进去后给停车场上锁，其他车就进不去了。car2    car3    car4    同时只能有一个线程占有公共资源。互斥锁是一种保护共享资源的方法。当一个线程拥有互斥锁的时候，另一个线程若是等待锁， 则其就会被挂起，从而保证只有一个线程会操作共享数据。2.例...
RTX5 | 互斥量01 - 互斥量的使用
wallace89的博客
06-23 3119
文章目录一、前言二、实验目的三、API3.1、osMutexAttr_t3.2、osMutexNew3.3、osMutexAcquire3.4、osMutexGetOwner3.5、osMutexRelease四、代码4.1、main.h4.2、main.c五、Event Recorder调试5.1、System Analyzer5.2、RTX RTOS5.3、Debug (printf) Viewer 一、前言 互斥量通常在各种各样的操作系统上用于资源管理。MCU上的很多资源能被复用，但是，在同一个时刻
互斥量知识
m0_63702526的博客
09-18 1097
9.18
互斥量概念，用法，死锁演示及解决详解
小郑在路上
12-02 2615
一、互斥量（mutex）的基本概念 1.我们为什么需要互斥量 这就涉及到了共享资源的概念，例如：买票这一行为，（票就是我们的共享资源） 假设有两个窗口 1 和 2号窗口（可以看成是两个"售票"子线程）， 这时有两人同时购买从上海到北京的票，同样挑中了A1座，如果这时不对这类 行为做任何处理，就会造成两个人同时买到A1票的错误反馈。 保护共享数据，操作时，某个线程 用代码把共享数据锁住->操作数据->解锁；其他想操作共享数据的线程必须等待解锁->锁定住->操作->解锁; 以上
互斥量(互斥锁)
热门推荐
月雲之霄的博客
10-26 1万+
一、互斥量mutex Linux提供一把互斥锁mutex(也称之为互斥量) 每个线程在对资源操作前都尝试先加锁，成功加锁才能操作，操作结束后解锁。 资源还是共享的，线程间也还是竞争的，但通过锁将资源的访问变为互斥操作，而后与时间有关的错误也不会在产生了。 如图所示： 但是应该注意：同一个时刻，只能有一个线程持有该锁。 当A线程对某个全局变量加锁访问，B在访问前尝试加锁，拿不到锁，B阻...
Linux下互斥与死锁相关知识——学习笔记
Love丶伊卡洛斯
08-11 371
一、同步、竞争、互斥 当多个线程同时访问其共享的资源时，需要相互协调，以防止出现数据不一致、不完整的问题，能达到这种状态叫线程同步。 而有些资源在同一时刻只有一个线程访问，对于这种资源的访问需要竞争。 当资源获取到后，能够防止资源被其他线程抢占（再次获取）的技术叫互斥。 二、互斥量（锁） pthread_mutex_t mutex = PTHREAD_MUTEX_INITALIZE...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值