线程同步之互斥锁

最新推荐文章于 2024-07-09 15:38:01 发布
最新推荐文章于 2024-07-09 15:38:01 发布
阅读量1.2k 收藏 3
点赞数 1
分类专栏： Linux应用开发 文章标签： linux 多线程 同步
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/l384011291/article/details/112442155
版权

目录

一、概述

产生死锁的情况：

一些注意事项：

二、程序接口

头文件：

链接库：

数据结构：

函数清单：

函数详解：

三、示例程序（仅供参考）

四、参考文献

一、概述

互斥锁一般用于线程同步，其主要用于保护临界区，防止多个线程同时修改某些数据。互斥锁使用不当会造成死锁的情况，可能会导致程序卡死，这个需要开发者格外小心。

 

产生死锁的情况：

1、一个函数里面对一个互斥锁加锁之后，因为某个原因，没有解锁就结束了。比如：函数中没有解锁就return了。（对于这种情况我一般是使用goto替代return进行处理，就是在函数末尾设置一个标签，跳转至该标签会进行解锁操作）

2、多个线程多个互斥锁的情况，线程1对互斥锁A加锁，然后它试图访问线程2的资源，对互斥锁B尝试上锁，但是线程2已经对互斥锁B加锁了，同时线程2也尝试访问线程1的资源，对互斥锁A尝试上锁，这样的话两个线程就会出现互相等待对方释放互斥锁的情况。（对于这种情况，我一般是把这次操作所有需要获取的锁在开头就获取好，而不是在需要的时候才来获取）

3、当持有某个锁的线程异常退出的时候，这个时候线程来不及释放锁，会造成死锁的情况。（对于该情况可以通过设置互斥锁的“健壮性”属性来避免。）

 

一些注意事项：

1、互斥锁使用之前一定要进行初始化，否则会出现错误并导致程序崩溃，初始化可以使用宏PTHREAD_MUTEX_INITIALIZER（全局互斥锁）或pthread_mutex_init()函数。

2、互斥锁属性结构使用之前也一定要初始化，否则会造成互斥锁无法上锁的情况。

3、某个线程对互斥锁进行上锁操作，那么解锁操作一定要在本线程来进行，不能由其他线程进行解锁（会返回错误）。

 

二、程序接口

头文件：

#include <pthread.h>

#include <errno.h>

 

链接库：

-lpthread

 

数据结构：

pthread_mutext_t：互斥锁结构

pthread_mutexattr_t：互斥锁属性结构

注意：以上两个结构都需要初始化才能用，否则会出现不可预知的错误

 

函数清单：

int pthread_mutex_init(pthread_mutext_t *restrict mutex, const pthread_mutexattr_t *restrict attr);

int pthread_mutex_destroy(pthread_mutex_t *mutex);

int pthread_mutex_lock(pthread_mutex *mutex);

int pthread_mutex_unlock(pthread_mutex *mutex);

int pthread_mutexattr_init(pthread_mutexattr_t* attr);

int pthread_mutexattr_destroy(pthread_mutexattr_t* attr);

int pthread_mutexattr_getrobust(const pthread_mutexattr_t *attr, int *robustness);

int pthread_mutexattr_setrobust(const pthread_mutexattr_t *attr, int robustness);

int pthread_mutex_consistent(pthread_mutex_t *mutex)；

int pthread_mutexattr_getpshared(const pthread_mutexattr_t *attr, int *pshared);

int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr, int pshared);

int pthread_mutexattr_settype(pthread_mutexattr_t* attr, int type);

int pthread_mutexattr_gettype(const pthread_mutexattr_t* restrict attr, int* type);

 

 

函数详解：

int pthread_mutex_init(pthread_mutext_t *restrict mutex, const pthread_mutexattr_t *restrict attr);

该函数用于初始化互斥锁，参数如下：

mutex：需要进行初始化的互斥锁。

attr：互斥锁的属性，如果为NULL则使用默认属性。

返回值：0为成功；否则返回错误编号

 

int pthread_mutex_destroy(pthread_mutex_t *mutex);

该函数用于销毁互斥锁，参数如下：

mutex：需要进行销毁的互斥锁。

返回值：0为成功；否则返回错误编号。

 

int pthread_mutex_lock(pthread_mutex *mutex);

该函数用于互斥锁上锁，参数如下：

mutex：互斥锁结构指针。

返回值：0为成功；否则返回错误编号。

 

int pthread_mutex_unlock(pthread_mutex *mutex);

该函数用于互斥锁解锁，参数如下：

mutex：互斥锁结构指针。

返回值：0为成功；否则返回错误编码。

 

int pthread_mutexattr_init(pthread_mutexattr_t* attr);

该函数用于初始化互斥锁属性结构，参数如下：

attr：互斥锁属性结构

返回值：0为成功；否则返回错误编号

 

int pthread_mutexattr_destroy(pthread_mutexattr_t* attr);

该函数用于销毁互斥锁属性结构，参数如下：

attr：互斥锁属性结构

返回值：0为成功；否则返回错误编号

 

int pthread_mutexattr_getrobust(const pthread_mutexattr_t *attr, int *robustness);

该函数用于获取互斥锁的健壮属性，参数如下：

attr：互斥锁属性结构指针。

robustness：用于获取健壮属性的变量。

返回值：0为成功，否则返回错误编号。

 

int pthread_mutexattr_setrobust(const pthread_mutexattr_t *attr, int robustness);

该函数用于设置互斥锁的“健壮性”，以防止因为某个线程/进程的异常退出，造成其持有的互斥锁未解锁，进而导致其他线程/进程死锁的情况。设置了该属性之后，当某个线程/进程异常退出时，该互斥锁会使阻塞在 pthread_mutex_lock()的线程返回EOWNERDEAD（有多个线程在等待互斥锁的时候，只有一个会返回EOWNERDEAD，其他返回非0的错误值），之后若需要继续使用该互斥量，应该先调用pthread_mutex_consistent，然后再对其进行解锁，或将其重新初始化（先销毁再初始化），即恢复了之后才能继续使用，否则直接加锁仍会造成死锁的情况（PS：返回EOWNERDEAD之后，如果直接对该互斥锁先进行解锁操作，然后再加锁，那么这次的加锁操作会失败，也就是这个互斥锁已经是不可用的状态了）。参数如下：

attr：互斥锁属性结构指针。

robustness：设置的健壮性的值，默认为PTHREAD_MUTEX_STALLED，设置为该值时，线程/进程异常退出时，会导致死锁的情况；当设置为PTHREAD_MUTEX_ROBUST时，则线程/进程异常退出时pthread_mutex_lock()会返回EOWNERDEAD。

返回值：0为成功，否则返回错误编号。

加了该属性之后，对于获取锁失败的情况，可以参考如下代码处理：

ret = pthread_mutex_lock(&myMutex);

if(ret != 0)

{

if(ret == EOWNERDEAD)

{

pthread_mutex_consistent(&myMutex);

pthread_mutex_unlock(&myMutex);

pthread_mutex_lock(&myMutex);

}

}

 

int pthread_mutex_consistent(pthread_mutex_t *mutex)；

该函数用于“健壮”的互斥锁，当pthread_mutex_lock返回EOWNERDEAD时，应该先使用该函数设置互斥锁，然后再解锁，否则会出现后面无法再对该互斥锁进行加锁操作的情况。参数如下：

mutex：互斥锁指针

返回值：0为成功，否则返回错误编号。

 

int pthread_mutexattr_getpshared(const pthread_mutexattr_t *attr, int *pshared);

该函数用于获取互斥锁的“共享”属性，参数如下：

attr： 互斥锁属性结构指针

pshared：需要获取的“共享”属性

 

int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr, int pshared);

该函数用于设置互斥锁的“共享”属性，设置了“共享”属性之后，互斥锁可放在共享内存用于进程同步，参数如下：

attr： 互斥锁属性结构指针

pshared：需要设置的“共享”属性

返回值：0为成功，否则返回错误编号

 

int pthread_mutexattr_settype(pthread_mutexattr_t* attr, int type);

该函数用于设置互斥锁的类型属性，有以下几种类型：

 

参数如下：

attr：互斥锁属性结构指针

type：类型

返回值：0为成功，否则返回错误编号

 

int pthread_mutexattr_gettype(const pthread_mutexattr_t* restrict attr, int* type);

用于获取互斥锁的类型属性，参数如下：

attr：互斥锁属性结构指针

type：类型指针，类型可以参考上面的图

返回值：0为成功，否则返回错误编号

 

三、示例程序（仅供参考）

#include "output.h"
#include <stdio.h>
#include <pthread.h>
#include <errno.h>
#include <unistd.h>

//定义自己的打印函数
#define Output_Printf(str, args...) printf("[%s:%d]" str, __FUNCTION__, __LINE__, ##args)

pthread_mutex_t myMutex;
//互斥锁测试线程
static void* Thread_MutexTest(void* arg)
{
	int threadID = *(int*)arg;
	int ret = 0;

	Output_Printf("Thread[%d] start!\n", threadID);
	ret = pthread_mutex_lock(&myMutex);
	if(ret != 0)
	{
		if(ret == EOWNERDEAD)//对于持有锁的线程突然挂掉之后的处理
		{
			Output_Printf("Thread[%d]: Mutex lock owner dead!\n", threadID);
			pthread_mutex_consistent(&myMutex);
			pthread_mutex_unlock(&myMutex);
			pthread_mutex_lock(&myMutex);
			Output_Printf("Thread[%d] Lock again!\n", threadID);
		}
		else
			Output_Printf("pthread_mutex_lock error!\n");
	}
	Output_Printf("Thread[%d] lock!\n", threadID);//成功获取到锁
	sleep(2);
	if(threadID == 1)//制作某个线程在持有锁的情况下异常退出的情景，测试robust属性
		return NULL;
	pthread_mutex_unlock(&myMutex);
	Output_Printf("Thread[%d] unlock!\n", threadID);
	return NULL;
}

//互斥锁
void Mutex_Test()
{
	pthread_mutexattr_t myMutexAttr;
	int ret = 0, threadNum = 3, loop = 0;
	pthread_t pthreadID;

    //初始化互斥锁的属性结构
	ret = pthread_mutexattr_init(&myMutexAttr);
	if(ret != 0)
	{
		Output_Printf("Can not init mutex attribute!\n");
		return;
	}

   	//设置robust属性
	ret = pthread_mutexattr_setrobust(&myMutexAttr, PTHREAD_MUTEX_ROBUST);
	if(ret != 0)
	{
		Output_Printf("Can not set mutex robust attribute!\n");
		return;
	}

    //用设置好的属性初始化互斥锁
	ret = pthread_mutex_init(&myMutex, &myMutexAttr);
	if(ret != 0)
	{
		Output_Printf("Init mutex fail!\n");
		return;
	}

   	//创建线程
	for(loop = 0; loop < threadNum; loop++)
	{
		pthread_create(&pthreadID, NULL, Thread_MutexTest, &loop);
		sleep(1);
	}

    //等待上锁
	ret = pthread_mutex_lock(&myMutex);
	if(ret != 0)
	{
		if(ret == EOWNERDEAD)//对于持有锁的线程突然挂掉之后的处理
		{
			Output_Printf("Main: Mutex lock owner dead!\n");
			pthread_mutex_consistent(&myMutex);
			pthread_mutex_unlock(&myMutex);
			pthread_mutex_lock(&myMutex);
			Output_Printf("Lock again!\n");
		}
		else
			Output_Printf("Main pthread_mutex_lock error!\n");
	}
	Output_Printf("Main lock!\n");//成功获取到锁
	sleep(2);
	pthread_mutex_unlock(&myMutex);
	Output_Printf("Main unlock!\n");

    //防止主线程释放锁后马上结束，导致整个程序退出
	getchar();
}

上面程序的运行结果如下：

逐句分析打印信息：

[Thread_MutexTest:24]Thread[0] start! //线程0启动。

[Thread_MutexTest:38]Thread[0] lock! //线程0获取到互斥锁。

[Thread_MutexTest:24]Thread[1] start! //线程1启动，因为现在是线程0持有互斥锁，所以线程1阻塞。

[Thread_MutexTest:43]Thread[0] unlock! //线程0释放互斥锁。

[Thread_MutexTest:38]Thread[1] lock! //线程1获取到互斥锁，并且根据程序设定，线程1将不释放互斥锁就退出线程，制造线程异常退出的情况。

[Thread_MutexTest:24]Thread[2] start! //线程2启动。

[Thread_MutexTest:30]Thread[2]: Mutex lock owner dead! //由于线程1在持有互斥锁的时候就退出了，因此线程2在获取互斥锁的时候将出现EOWNERDEAD的错误，需进行处理。

[Mutex_Test:100]Main lock! //线程2执行了pthread_mutex_consistent(&myMutex)和pthread_mutex_unlock(&myMutex)之后，主线程main先获取到互斥锁，此时线程2将阻塞。

[Mutex_Test:103]Main unlock! //主线程释放锁。

[Thread_MutexTest:38]Thread[2] lock! //线程2终于获取到锁。

[Thread_MutexTest:43]Thread[2] unlock! //线程释放锁。

//程序结束

 

四、参考文献

1、《Unix环境高级编程》（中文第三版）

2、《Unix网络编程卷二：进程间通信》（中文第二版）

 

 

 

楚君文
关注
专栏目录
Qt 多线程同步之互斥锁
希望能帮助大家，希望大家多多支持，你们的支持是我前进的动力。
03-15 1585
生产者-消费者模型 1.QMutex QMutex需要配对使用lock()和unlock()来实现代码段的保护 #ifndef MYTHREAD_H #define MYTHREAD_H #include <QThread> #include <QQueue> #include <QMutex> #include <QDebug> static int data = 100; static QQueue<int> que; stat
死锁
luciusvorenus
04-23 231
死锁的现象： 1. 线程试图对同一个互斥量A加锁两次。这种情况主要是在编程时不经意之间发生的。当对互斥量加锁后，如果再次加锁导致该线程阻塞等待锁被释放，但是该锁其实就被线程自己占有了，因此造成了自己把自己死锁住了。解决方法：在加锁之前应该检查之前是否加过锁还未解锁； 2. 当线程要同时获得多个共享资源才能完成工作时，如线程1拥有A锁，请求获得B锁；线程2拥有B锁，请求获得A锁。解决方法：当线程...
互斥锁的使用以及注意事项以及互斥锁demo
weixin_43304992的博客
11-20 1799
对公共数据进行保护。所有线程【应该】在访问公共数据前先拿锁再访问。但，锁本身不具备强制性。 使用mutex(互斥量、互斥锁)一般步骤： pthread_mutex_init 函数 初始化一个互斥锁(互斥量) —> 初值可看作1 int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr); 参 1：传出参数，调用时应传 &mutex re
【线程系列之二】线程锁之互斥锁介绍
最新发布
qq_40604302的博客
07-09 1295
公平的互斥量会按照线程请求锁的顺序来授予锁，从而避免了饥饿现象（即某个线程长时间得不到锁的情况）。：互斥量保证在任何时候，只有一个线程可以持有锁并访问受保护的资源。：进程已经保持了至少一个资源，但又提出了新的资源请求，而该资源已被其他进程占有，此时请求进程被阻塞，但对自己已获得的资源保持不放。：进程所获得的资源在未使用完毕之前，不能被其他进程强行夺走，即只能由获得该资源的进程自己来释放（只能是主动释放)。死锁是指在执行过程中，两个或两个以上的进程或线程由于竞争资源或彼此通信而阻塞，导致无法继续执行的情况。
进程互斥锁
qq_37369726的博客
12-28 1084
互斥锁的作用就是让多个子进程争抢一个资源的同时，有序进行而不会同时被系统资源调用执行。就好比多个人去打印店打印东西，一台打印机只能一个人一个人打，这样打印出来的东西就会是他的。当然串行的方式也能解决这个问题，但是谁先谁后，你没办法确定，你能决定程序执行的先后，却没办法决定系统资源调用的先后。互斥锁就是让多个进程争抢一把锁，有锁的先，等它完成后，再次争抢。 from multiprocessing import Process from multiprocessing import Lock import t
【C++ 语言】pthread_mutex_t 互斥锁
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
08-27 3717
线程同步机制 互斥锁 互斥锁使用示例
linux 线程同步与互斥：互斥锁 多线程访问共享资源时，使用互斥锁进行控制
alpha_love的博客
03-16 952
为什么需要互斥锁？ 在多任务操作系统中，同时运行的多个任务可能都需要使用同一种资源。这个过程有点类似于，公司部门里，我在使用着打印机打印东西的同时（还没有打印完），别人刚好也在此刻使用打印机打印东西，如果不做任何处理的话，打印出来的东西肯定是错乱的。 下面我们用程序模拟一下这个过程，线程一需要打印“ hello ”，线程二需要打印“ world ”，不加任何处理的话，打印出来的内容会错乱： ...
Linux多线程编程-互斥锁
热门推荐
luoxn28的专栏
07-04 1万+
互斥锁         多线程编程中，(多线程编程)可以用互斥锁(也称互斥量)可以用来保护关键代码段，以确保其独占式的访问，这有点像二进制信号量。POSIX互斥锁相关函数主要有以下5个： #include int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr); int pthr
十一.linux多线程同步之互斥锁、信号量、条件量
Mr.Wang的博客
05-04 2767
笔记：https://note.youdao.com/ynoteshare1/index.html?id=1b529d966d34b16f3bdd828be48364e4&type=note 目录 一.线程同步之信号量 1、任务：用户从终端输入任意字符然后统计个数显示，输入end则结束 2、信号量的介绍和使用（多线程实行的引入） (1)、信号量初始化 (2)、等待信号量 (3...
Python实现的多线程同步与互斥锁功能示例
09-21
### Python实现的多线程同步与互斥锁功能详解 在多线程编程中，确保线程间的正确同步是至关重要的。特别是在多个线程访问共享资源时，如果没有正确的同步机制，可能会导致竞态条件（race condition），从而引发不可...
Linux线程同步之互斥锁
专注【PostgreSQL源码学习&研究】
12-14 464
一、我们知道，同一个进程中的所有线程是共享进程资源的。因此多线程中，线程同步则成为了一个很重要的话题。所谓“同步”，即“协同步调，按预定的先后次序进行运行”。所以“既需要在线程间共享数据，又需要以一致的顺序在线程间执行一组操作”。则必须借助于线程的同步手段、机制来实现。线程同步方法较多，常用到的有:互斥锁、条件变量（配合互斥锁）、信号量、读写锁、自旋锁等。其中互斥锁是所有“线程同步”手段中最为简单...
ThreadX内核源码分析 - 线程同步之互斥锁及动态优先级
arm7star的博客
03-12 1851
1、ThreadX互斥锁介绍 互斥锁一般用来锁多线程都需要访问的临界资源，这些资源不能并发操作，例如对某个内存的互斥读写，这个读写很快，但是不能多线程同时进行，所以需要加互斥锁； 占用互斥锁的线程没能执行，可能是被高优先级线程抢占了或者临界资源里面调用了阻塞操作；高优先级线程想要访问临界资源就必须等待低优先级线程被调度然后释放互斥锁，如果低优先级线程不提高优先级不被执行的话，那么高优先级的线程就会阻塞，直到所有高优先级线程都阻塞了，才能轮到占用互斥锁的低优先级线程执行，这样高优先级线程就得不到及时处理，
线程同步---互斥锁和用锁不当造成的死锁现象
DongZhaoCheng
07-09 1887
所谓互斥锁，其实是附加了一个条件，也就是在获得锁的条件下才能运行锁住的代码 锁应该是多个线程的共享资源，这样才能起到避免竞争的作用 二、死锁 1.什么是死锁？ 死锁：是因为线程在加锁时使用不当，造成的所有的线程都被阻塞的情况，并且线程的阻塞无法被打开，属于无解状态，就是死锁 2.死锁场景 ①加锁之后忘记解锁 ②重复加锁，造成死锁 ③程序中有多个共享资源，因此有很多锁，随意加锁，导致互相被阻塞（互锁）.........
线程同步之互斥量加锁解锁
qiao代码的木偶人的博客
09-23 216
1.创建及销毁互斥锁 #include <pthread.h> int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr); int pthread_mutex_destroy(pthread_mutex_t mutex); // 返回：若成功返回0，否则返回错误编号 要用默认的属性初始化互斥量，只需把attr设置为NULL。 2.加锁及解锁 #in
互斥锁和条件变量锁注意事项
dew0927的博客
04-19 152
如果互斥锁变量是静态分配的，那么我们可以把它初始化成常值PTHREAD_MUTEX_INITIALIZER 例如 ：static pthread_mutex_t lock =PTHREAD_MUTEX_INITIALIZER; 如果互斥锁是动态分配的（例如malloc new）或者分配在共享内存区中，那么我们在运行之时通过调用pthread_mutex_init函数初始化...
互斥锁的使用
XHumble的博客
11-18 600
这里简单介绍互斥锁的使用 互斥锁变量类型 pthread_mutex_t 互斥锁初始化 动态初始化 int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *restrict attr); 参数说明： mutex：传入互斥锁的地址 attr：属性，一般传递NULL采用默认属性 静态初始化 pthread_mutex_t mutex = PTHREAD_MUTEX_I...
计算机原理-互斥锁实现原理以及使用注意点
Shanks
06-28 6553
互斥锁可以说是程序员必备，那必备技能使用有哪些注意事项呢？它怎么实现的呢？下面我们来分析下。 互斥锁基本原理 互斥锁是一个二元变量，其状态为开锁(允许0)和上锁(禁止1)，将某个共享资源与某个特定互斥锁在逻辑上绑定(要申请该资源必须先获取锁)。 访问公共资源前，必须申请该互斥锁，若处于开锁状态，则申请到锁对象，并立即占有该锁，以防止其他线程访问该资源；如果该互斥锁处于锁定...
线程间通信——互斥锁
qq_48633111的博客
01-04 1170
一、互斥锁 互斥锁通过简单的枷锁方法来保证对共享资源的原子操作。互斥锁只有两种状态：上锁和解锁，可以把互斥锁看成某种意义上的全局变量。在同一时刻只能有一个线程持有某个互斥锁，拥有互斥锁的线程能够对共享资源进行操作。若线程对一个已经上锁的互斥锁加锁，该线程就会睡眠，直到其他线程释放互斥锁为止。可以说，这把互斥锁保证每个线程对共享资源按顺序进行原子操作。 二、主要函数 /* Initialize a mutex. */ ...
【Linux多线程编程】互斥锁及其使用
BadBoyHolly的博客
02-03 460
Linux多线程编程讲解与实践，使用pthread线程库。
C语言线程同步和互斥锁
05-11
在多线程编程中，为了保证线程之间的数据同步和避免竞争条件，需要使用线程同步和互斥锁。 1. 线程同步：线程同步是指协调多个线程的执行顺序，以避免线程之间的竞争条件。常用的线程同步方法有：信号量、互斥锁、条件变量等。 2. 互斥锁：互斥锁是一种用于保护共享资源不被多个线程同时访问的锁。在访问共享资源前，需要获取互斥锁，访问结束后需要释放互斥锁。常见的互斥锁有：pthread_mutex_t、pthread_spinlock_t等。 下面是一个使用互斥锁的示例代码： ```c #include <pthread.h> pthread_mutex_t mutex; void *thread_func(void *arg) { // 加锁 pthread_mutex_lock(&mutex); // 访问共享资源 // 解锁 pthread_mutex_unlock(&mutex); return NULL; } int main() { pthread_t thread; // 初始化互斥锁 pthread_mutex_init(&mutex, NULL); // 创建线程 pthread_create(&thread, NULL, thread_func, NULL); // 等待线程结束 pthread_join(thread, NULL); // 销毁互斥锁 pthread_mutex_destroy(&mutex); return 0; } ``` 在上面的代码中，pthread_mutex_lock()函数用于加锁，pthread_mutex_unlock()函数用于解锁。在访问共享资源时，需要先获取互斥锁，访问结束后再释放互斥锁，这样可以保证在同一时刻只有一个线程可以访问共享资源，从而避免了竞争条件的出现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值