七、freeRTOS_互斥量的使用

最新推荐文章于 2024-05-13 23:59:44 发布
最新推荐文章于 2024-05-13 23:59:44 发布
阅读量718 收藏 7
点赞数
分类专栏： FreeRTOS_实战 文章标签： stm32
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41682371/article/details/126144706
版权

目录

1. 互斥量的理论讲解

1.1 解决优先级反转的问题

1.2 解决递归上锁/解锁的问题

 2. 互斥量的常规使用

2.1 常规使用

2.2 优先级反转的例子

2.3 使用继承（互斥量）解决优先级反转

3. 互斥量的缺陷和递归锁

互斥量就是保护临界资源，大家互斥的去使用这些资源。

1. 互斥量的理论讲解

  • 使用方法

  • 跟二进制信号量的对比

    • 能解决优先级反转的问题

    • 能解决递归上锁/解锁的问题

1.1 解决优先级反转的问题

在信号量中，A使用Take函数，然后printf，B发现A没有Give，所以B阻塞在哪里，等到A Give之后，B才来Take，使用二进制信号量如此完美的解决了该问题，但是你在看看下面这个场景！！！

 A在Take之后，进行printf，这时候C给Give了，然后D又来Take了，这时候A、D都在使用串口进行打印，所以乱套了，还是存在风险。

 本来举上面两个例子，就想说明对于临界资源应该是谁上锁，谁来解锁，但是很不幸的是，FreeRTOS的互斥锁，并没有在代码上实现这点，那后续出现上述的问题怎么办呢？答案是只能凭借程序猿的自觉性，写出完美的代码，既然没有实现这一点你讲这么多干啥呢？但是它还有如下的优势：

  • 跟二进制信号量的对比

    • 能解决优先级反转的问题

    • 能解决递归上锁/解锁的问题

 假设有A、B、C三个任务，优先级分别是1、2、3。

图1：假设A先运行，获得了锁lock，然后B在运行，B的优先级比A高，可以抢占A，然后在轮到C在运行，在C函数中，它也想获得那把锁，于是它调用lock函数，因为锁已经被A使用了，所以进入到阻塞状态，现在轮到了B运行，在B运行的过程中，假设它一直没有放弃cpu资源，在这个过程中，A一直没有办法执行，在这种情况下，A的优先级最低，C的优先级最高，优先级最高的C被B给抢占了，这就是优先级高的程序反而不能被执行，这种现象就是优先级反转。

那怎么解决这个问题，解决这个问题的方法就是优先级继承。

图2：假设A先运行，获得了锁lock，然后B在运行，B的优先级比A高，可以抢占A，然后在轮到C在运行，在C函数中，它也想获得那把锁，于是它调用lock函数，因为锁已经被A使用了，所以进入到阻塞状态，C在调用lock的时候它还会做优先级继承，然后A的优先级就变成了3，A继承了C的优先级，这时候运行的不是B，运行的是A，A运行完之后，它进行unlock，释放这个互斥量，这时候A的优先级又变了1，然后轮到C在执行。第一次A lock的时候没有问题，第二次C lock的时候没有办法获得互斥量，所以提升C的优先级，在这个过程中C的优先级并没有被B来反转，这就是优先级继承。

1.2 解决递归上锁/解锁的问题

A先Take ，此时已经lock了，val也变为0了，这时候xxxlib()函数也Take了，这时候处于阻塞状态，两个人各自拿了一把锁，都在相互等待对方释放锁，此时就是死锁的状态了。

 解决该问题的，就要用到递归锁了。

递归锁除了优先级继承外，还有递归的的功能。

红色lock

        黑色lock

        黑色unlock

红色unlock

注意好层次，应该就没有问题了。

 2. 互斥量的常规使用

  • 常规使用：

    • 源码：16_freertos_example_mutex

    • 来自视频配套源码：15_freertos_example_semaphore

  • 优先级反转的例子:

    • 源码：17_freertos_example_mutex_inversion

    • 来自文档配套的源码FreeRTOS_17_mutex_inversion

  • 使用继承（互斥量）解决优先级反转

    • 源码：18_freertos_example_mutex_inheritance

    • 来自文档配套的源码FreeRTOS_18_mutex_inheritance

2.1 常规使用

二级制信号量初始值是0，创建后需要Give一次；互斥量初始值是1，创建后不需要Give一次。

static int sum = 0;
static volatile int flagCalcEnd = 0;
static volatile int flagUARTused = 0;

static SemaphoreHandle_t xSemCalc;
static SemaphoreHandle_t xSemUART;


void Task1Function(void * param)
{
	volatile int i = 0;
	while (1)
	{
		for (i = 0; i < 10000000; i++)
			sum++;
		//printf("1");
		xSemaphoreGive(xSemCalc);
		vTaskDelete(NULL);
	}
}

void Task2Function(void * param)
{
	while (1)
	{
		//if (flagCalcEnd)
		flagCalcEnd = 0;
		xSemaphoreTake(xSemCalc, portMAX_DELAY);
		flagCalcEnd = 1;
		printf("sum = %d\r\n", sum);
	}
}

void TaskGenericFunction(void * param)
{
	while (1)
	{
		xSemaphoreTake(xSemUART, portMAX_DELAY);
		printf("%s\r\n", (char *)param);
		xSemaphoreGive(xSemUART);
		vTaskDelay(1);
	}
}


/*-----------------------------------------------------------*/

int main( void )
{
	TaskHandle_t xHandleTask1;
		
#ifdef DEBUG
  debug();
#endif

	prvSetupHardware();

	printf("Hello, world!\r\n");
	xSemCalc = xSemaphoreCreateCounting(10, 0);
	//xSemUART = xSemaphoreCreateBinary();
	//xSemaphoreGive(xSemUART);
	
	xSemUART = xSemaphoreCreateMutex();

	xTaskCreate(Task1Function, "Task1", 100, NULL, 1, &xHandleTask1);
	xTaskCreate(Task2Function, "Task2", 100, NULL, 1, NULL);

	xTaskCreate(TaskGenericFunction, "Task3", 100, "Task 3 is running", 1, NULL);
	xTaskCreate(TaskGenericFunction, "Task4", 100, "Task 4 is running", 1, NULL);

	/* Start the scheduler. */
	vTaskStartScheduler();

	/* Will only get here if there was not enough heap space to create the
	idle task. */
	return 0;
}

Task3、Task4互斥的使用串口，他们的信息并没有掺杂在一起。 

2.2 优先级反转的例子

在main函数中，我们创建了（低/中/高优先级）的任务，先让高优先级的任务，打印“HPTask start”之后，故意让它vTaskDelay 10ms，然后让中等优先级的任务，打印 "MPTask start"之后，故意让它vTaskDelay 30ms，这时只剩下最低优先级的任务了，在最低优先级任务里，先是获得锁，故意耗时很久，在释放锁，在vTaskDelay 10ms，这时候到高优先级任务了，打印“HPTask wait for Lock”之后，他想获得这把锁，这个锁之前已经被低优先级的任务获得了，高优先级任务进入阻塞状态，然后又轮到低优先级的任务继续执行，这时中优先级的30ms到了，中优先级任务一直执行，没有主动放弃cpu资源，于是中优先级的任务一直在执行，这时候高优先级的任务一直没有机会执行，这就是优先级反转。

怎么解决这个问题，解决问题的关键就是优先级继承。

static volatile uint8_t flagLPTaskRun = 0;
static volatile uint8_t flagMPTaskRun = 0;
static volatile uint8_t flagHPTaskRun = 0;

static void vLPTask( void *pvParameters );
static void vMPTask( void *pvParameters );
static void vHPTask( void *pvParameters );


/* 互斥量/二进制信号量句柄 */
SemaphoreHandle_t xLock;

int main( void )
{
	prvSetupHardware();
	
    /* 创建互斥量/二进制信号量/ */
    xLock = xSemaphoreCreateBinary( );
	xSemaphoreGive(xLock);


	if( xLock != NULL )
	{
		/* 创建3个任务：LP,MP,HP（低/中/高优先级）
		 */
		xTaskCreate( vLPTask, "LPTask", 1000, NULL, 1, NULL );
		xTaskCreate( vMPTask, "MPTask", 1000, NULL, 2, NULL );
		xTaskCreate( vHPTask, "HPTask", 1000, NULL, 3, NULL );

		/* 启动调度器 */
		vTaskStartScheduler();
	}
	else
	{
		/* 无法创建互斥量/二进制信号量 */
	}

	/* 如果程序运行到了这里就表示出错了，一般是内存不足 */
	return 0;
}

/*-----------------------------------------------------------*/

/*-----------------------------------------------------------*/
static void vLPTask( void *pvParameters )
{
	const TickType_t xTicksToWait = pdMS_TO_TICKS( 10UL );	
	uint32_t i;
	char c = 'A';

	printf("LPTask start\r\n");
	
	/* 五险循环 */
	for( ;; )
	{	
		flagLPTaskRun = 1;
		flagMPTaskRun = 0;
		flagHPTaskRun = 0;

		/* 获得互斥量/二进制信号量 */
		xSemaphoreTake(xLock, portMAX_DELAY);
		
		/* 耗时很久 */
		
		printf("LPTask take the Lock for long time");
		for (i = 0; i < 500; i++) 
		{
			flagLPTaskRun = 1;
			flagMPTaskRun = 0;
			flagHPTaskRun = 0;
			printf("%c", c + i);
		}
		printf("\r\n");
		
		/* 释放互斥量/二进制信号量 */
		xSemaphoreGive(xLock);
		
		vTaskDelay(xTicksToWait);
	}
}

static void vMPTask( void *pvParameters )
{
	const TickType_t xTicksToWait = pdMS_TO_TICKS( 30UL );	

	flagLPTaskRun = 0;
	flagMPTaskRun = 1;
	flagHPTaskRun = 0;

	printf("MPTask start\r\n");
	
	/* 让LPTask、vHPTask先运行 */	
	vTaskDelay(xTicksToWait);
	
	/* 无限循环 */
	for( ;; )
	{	
		flagLPTaskRun = 0;
		flagMPTaskRun = 1;
		flagHPTaskRun = 0;
	}
}

static void vHPTask( void *pvParameters )
{
	const TickType_t xTicksToWait = pdMS_TO_TICKS( 10UL );	

	flagLPTaskRun = 0;
	flagMPTaskRun = 0;
	flagHPTaskRun = 1;

	printf("HPTask start\r\n");
	
	/* 让LPTask先运行 */	
	vTaskDelay(xTicksToWait);
	
	/* 无限循环 */
	for( ;; )
	{	
		flagLPTaskRun = 0;
		flagMPTaskRun = 0;
		flagHPTaskRun = 1;
		printf("HPTask wait for Lock\r\n");
		
		/* 获得互斥量/二进制信号量 */
		xSemaphoreTake(xLock, portMAX_DELAY);
		
		flagLPTaskRun = 0;
		flagMPTaskRun = 0;
		flagHPTaskRun = 1;
		
		/* 释放互斥量/二进制信号量 */
		xSemaphoreGive(xLock);
	}
}

运行结果：

2.3 使用继承（互斥量）解决优先级反转

在main函数中，改为下面的代码，即可解决优先级反转的问题。 

     /* 创建互斥量/二进制信号量/ */
    //xLock = xSemaphoreCreateBinary( );
	//xSemaphoreGive(xLock);
	xLock = xSemaphoreCreateMutex( );

运行结果：

3. 互斥量的缺陷和递归锁

本节源码：19_freertos_example_mutex_recursive，源自16_freertos_example_mutex

  • 对于互斥量，本意是：谁持有，就由谁释放

  • 但是FreeRTOS并没有实现这点：A持有，B也可以释放

  • 递归锁实现了

    • 谁持有，就由谁释放

    • 递归上锁/解锁

其实在linux中，互斥锁也没有实现这一点，谁持有，谁释放 。

以下运行结果，与任务1、任务2无关，代码中没有删除任务1、任务2的相关代码。

static int sum = 0;
static volatile int flagCalcEnd = 0;
static volatile int flagUARTused = 0;

static SemaphoreHandle_t xSemCalc;
static SemaphoreHandle_t xSemUART;


void Task1Function(void * param)
{
	volatile int i = 0;
	while (1)
	{
		for (i = 0; i < 10000000; i++)
			sum++;
		//printf("1");
		xSemaphoreGive(xSemCalc);
		vTaskDelete(NULL);
	}
}

void Task2Function(void * param)
{
	while (1)
	{
		//if (flagCalcEnd)
		flagCalcEnd = 0;
		xSemaphoreTake(xSemCalc, portMAX_DELAY);
		flagCalcEnd = 1;
		printf("sum = %d\r\n", sum);
	}
}

void TaskGenericFunction(void * param)
{
	int i;
	while (1)
	{
		xSemaphoreTakeRecursive(xSemUART, portMAX_DELAY);

		printf("%s\r\n", (char *)param);
		for (i = 0; i < 10; i++)
		{
			xSemaphoreTakeRecursive(xSemUART, portMAX_DELAY);
			printf("%s in loop %d\r\n", (char *)param, i);
			xSemaphoreGiveRecursive(xSemUART);
		}
		
		xSemaphoreGiveRecursive(xSemUART);
		vTaskDelay(1);
	}
}

void Task5Function(void * param)
{
	vTaskDelay(10);
	while (1)
	{
		while (1)
		{
			if (xSemaphoreTakeRecursive(xSemUART, 0) != pdTRUE)
			{
				xSemaphoreGiveRecursive(xSemUART);			
			}
			else
			{
				break;
			}
		}
		printf("%s\r\n", (char *)param);
		xSemaphoreGiveRecursive(xSemUART);
		vTaskDelay(1);
	}
}


/*-----------------------------------------------------------*/

int main( void )
{
	TaskHandle_t xHandleTask1;
		
#ifdef DEBUG
  debug();
#endif

	prvSetupHardware();

	printf("Hello, world!\r\n");
	xSemCalc = xSemaphoreCreateCounting(10, 0);
	//xSemUART = xSemaphoreCreateBinary();
	//xSemaphoreGive(xSemUART);
	
	//xSemUART = xSemaphoreCreateMutex();
	xSemUART = xSemaphoreCreateRecursiveMutex();

	xTaskCreate(Task1Function, "Task1", 100, NULL, 1, &xHandleTask1);
	xTaskCreate(Task2Function, "Task2", 100, NULL, 1, NULL);

	xTaskCreate(TaskGenericFunction, "Task3", 100, "Task 3 is running", 1, NULL);
	xTaskCreate(TaskGenericFunction, "Task4", 100, "Task 4 is running", 1, NULL);
	xTaskCreate(Task5Function, "Task5", 100, "Task 5 is running", 1, NULL);

	/* Start the scheduler. */
	vTaskStartScheduler();

	/* Will only get here if there was not enough heap space to create the
	idle task. */
	return 0;
}

运行结果： 

 

代码_钢琴家
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
freertos————互斥锁
qq_39854159的博客
09-01 6054
访问全局变量时需要添加互斥锁
FreeRTOS笔记（六）互斥量mutex
m0_58575472的博客
03-14 1451
在上图中，有个低优先级的任务（LP）和高优先级的任务（HP），两个任务都可以对一个资源进行操作。如果一个保存数据的全局变量在被一个任务操作的过程中，又被多个更高优先级的任务抢占并处理，那么最后这个支离破碎的数据将会毫无意义，破坏了数据的独立完整性；从外部的视角看，此时中等优先级的任务MD相当于抢占了高优先级的任务HP，而高优先级的任务HP表现起来却又像是有最低的优先级。优先级继承会暂时提高获得互斥量的任务的优先级，使得含有互斥量的任务的优先级和想要获取互斥量的任务中的最高优先级一样。宏定义会再次打开中断。
FreeRTOS互斥量
2301_78772787的博客
05-13 968
此时就需要引入互斥量。可见低优先级任务获得信号量时，高优先级想要获得信号量会进入阻塞状态，但此时中优先级会比高优先级先运行，会打断低优先级运行从而使得高优先级阻塞时间增长，当中优先级运行完毕，低优先级才继续运行，当低优先级释放信号量时，高优先级立刻获得信号量；当一个互斥信号量正在被一个低优先级的任务持有时， 如果此时有个高优先级的任 务也尝试获取这个互斥信号量，那么这个高优先级的任务就会被阻塞。以上图为例，系统中有3个不同优先级的任务H/M/L，最高优先级任务H和最低优先级任务L通过信号量机制，共享资源。
FreeRTOS_互斥量(Mutex)
w237838的博客
11-11 315
资源还是共享的，线程间也还是竞争的，但通过锁将资源的访问变为互斥操作，而后与时间有关的错误也不会在产生了。互斥量是一种特殊的信号量，所以获取、释放、删除的API基本和信号量的通用。互斥量的获取、释放一般不在中断中执行，所以此处无FromISR结尾函数。每个线程在对资源操作前都尝试先加锁，成功加锁才能操作，操作结束后解锁。注意：同一个时刻，只能有一个线程持有该锁。使用互斥量时，先创建，然后获取，再释放。互斥量是一种特殊的二进制信号量。在有多线程访问共享资源时使用。
线程同步——互斥锁
jay_zzs的博客
05-06 477
参考学习资料：进程线程互斥与同步 1. 互斥锁（互斥量） 1.1 变量类型：互斥锁类型 创建一把锁： //变量类型 变量名 pthread_mutex_t mutex 1.2 互斥锁的特点 多个线程访问共享数据时是串行的，避免数据混乱。 1.3 互斥锁缺点 效率低（由于所有的并行都转串行，所以效率比较低）。 1.4 互斥锁使用步骤 创建互斥锁： pthread...
STM32 FreeRTOS （五） 互斥量
DOF526570的博客
01-10 1165
当该任务释放这个互斥量时，该互斥量处于开锁状态，任务失去该互斥量的所有权。用互斥量处理不同任务对临界资源的同步访问时，任务想要获得互斥量才能进行资源访问，如果一旦有任务成功获得了互斥量，则互斥量立即变为闭锁状态，此时其他任务会因为获取不到互斥量而不能访问这个资源，任务会根据用户自定义的等待时间进行等待，直到互斥量被持有的任务释放后，其他任务才能获取互斥量从而得以访问该临界资源，此时互斥量再次上锁，如此一来就可以确保每个时刻只有一个任务正在访问这个临界资源，保证了临界资源操作的安全性。
FreeRTOS递归互斥信号量（含IAR和MDK）.rar
05-16
任务 Task1 运行的过程需要调用函数 printf，发现任务 ... 任务 Task2 执行完毕后，任务 Task3 恢复执行，Task3 释放互斥资源后，任务 Task1 得到互斥资源，从而可以继续执行。上面就是一 个产生优先级翻转问题的现象。
Free RTOS脑图文件之信号量（包括互斥量、递归互斥量）
05-02
FreeRTOS中可以通过使用互斥量和递归互斥量来避免死锁的发生。 总结 信号量是FreeRTOS中的一种同步机制，包括二值信号量、计数信号量、互斥量和递归互斥量等几种类型。正确使用信号量可以避免死锁和资源竞争，提高...
Windows下开箱后即时编译体验freeRTOS 的MDK demo工程，使用互斥量访问freeRTOS共享资源的实现
最新发布
06-16
已包含完整的freeRTOS依赖，可直观体验freeRTOS互斥量的使用，代码方面主要通过未使用互斥量访问共享资源的问题，以及使用互斥量解决访问共享资源问题！ 工程方面已经集成了freeRTOS的源码及相关互斥量使用示例，...
03_FreeRTOS_Bin_Semaphore.rar
07-04
信号量基本上用于将任务与系统中的其他事件同步。在FreeRTOS中，信号量是基于队列机制实现的。FreeRTOS中有4种信号量： - 二进制信号量 - 计数信号量 - 互斥信号量 - 递归信号量 ...二进制信号量的使用方法
stm32f103 FreeRTOS互斥信号量操作实验.zip
03-07
此程序为STM32F103 移植FreeRTOS系统工程源码，有需要可以学习参考，特别适合刚入门， 或者还没有入门的单片机开发者，可以提高代码开发周期，提升编程水平
FreeRTOS笔记之互斥量
m0_73804659的博客
01-30 1563
本文主要记录了FreeRTOS中的互斥量相关知识。
Arduino-ESP32使用FREERTOS使用相互排斥Mutex来解决竞争冒险Race Condition
weixin_56073998的博客
11-05 247
B站UP主孤独的二进制视频的学习笔记
FreeRTOS互斥锁
weixin_44355245的博客
04-16 505
拿电脑中文档举例：当一个文档已经被打开，这时如果再双击打开这个文档，则会提示“操作无法完成，因为文件已在word软件中打开”。这是因为操作系统在第一次打开文件的时候，给文件设置了一把锁。而如果后面还有程序想要操作文件，则因为上锁的原因，打开失败。避免暂停系统运转，纯逻辑层面解决了临界资源争抢的问题。另外还能解决优先级反转的问题锁的机制：资源我正在用，已经上锁，我什么时候解锁，你什么时候用。上锁：防止随意访问解锁：有权访问。
十六、FreeRTOS中如何实现互斥访问
m0_63702526的博客
03-20 342
简述互斥访问引入的必要性
FreeRTOS信号量详解第四讲（全网最全）——互斥信号量
留小乙的博客
10-26 7016
一、互斥信号量简介 互斥信号量其实就是一个拥有优先级继承的二值信号量，在同步的应用中（任务与任务或中断与任务之间的同步）二值信号量最适合。互斥信号量适合用于那些需要互斥访问的应用中。在互斥访问中互斥信号量相当于一个钥匙，当任务想要使用资源的时候就必须先获得这个钥匙，当使用完资源以后就必须归还这个钥匙，这样其他的任务就可以拿着这个钥匙去使用资源。互斥信号量使用和二值信号量相同的API操作函数，所以互斥信号量也可以设置阻塞时间，不同于二值信号量的是互斥信号量具有优先级继承的特性。当一个互斥信号量正在被一个低优先
Freertos-互斥量的基本使用
lu_linux的博客
09-28 302
Freertos-互斥量的基本使用
freertos 创建互斥量_FreeRTOS 从入门到精通10--资源管理（互斥锁与信号量）
weixin_39706861的博客
12-15 249
在上一讲中奔腾的心：FreeRTOS 从入门到精通9--中断管理​zhuanlan.zhihu.com我们探讨了中断管理在FreeRTOS中的概念和应用，在本讲中我们将讨论FreeRTOS一个十分重要的话题--资源管理（Resource Management），并借此介绍一个值得嵌入式开发者重视的现象--优先级倒置（Priority inversion ）。本个系列教程也将完结于此，很高兴读者能一...
【FreeRTOS学习 - 互斥量学习 (优先级继承-自锁-死锁-递归锁)】
晨少的博客
04-09 806
有A、B、C三个任务，优先级分别是 1、2、3，且A持有互斥锁，B和C一开始都故意延时，让A得以运行（这样低优先级的A就能先获得互斥锁）任务2故意执行"give"操作，看看能否释放别人持有的递归锁：不能。任务1阻塞时间到后继续运行，使用循环多次获得、释放递归锁。任务2运行，看看能否获得别人持有的递归锁：不能。任务1优先级最高，先运行，获得递归锁。任务1阻塞，让任务2得以运行。则让A暂时继承C的优先级。递归锁真正意义上实现了。
freeRTOS互斥信号量使用
03-09
FreeRTOS是一个开源的实时操作系统，它提供了一系列的功能和API来支持多任务处理。其中，互斥信号量是一种用于保护共享资源的机制。 在FreeRTOS中，互斥信号量可以通过以下步骤来使用： 1. 创建互斥信号量：使用`xSemaphoreCreateMutex()`函数创建一个互斥信号量。该函数返回一个指向互斥信号量的句柄。 2. 获取互斥信号量：使用`xSemaphoreTake()`函数获取互斥信号量。如果互斥信号量当前没有被其他任务占用，则获取成功，否则任务会被阻塞直到互斥信号量可用。 3. 使用共享资源：一旦获取到互斥信号量，任务可以安全地访问共享资源。 4. 释放互斥信号量：使用`xSemaphoreGive()`函数释放互斥信号量。这样其他任务就可以获取到该互斥信号量并访问共享资源。 需要注意的是，获取和释放互斥信号量的操作应该成对出现，以确保资源的正确保护。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值