【Linux C | 多线程编程】互斥量、信号量、条件变量对比总结

news2024/11/19 7:32:34

😁博客主页😁：🚀https://blog.csdn.net/wkd_007🚀
🤑博客内容🤑：🍭嵌入式开发、Linux、C语言、C++、数据结构、音视频🍭
⏰发布时间⏰：

本文未经允许，不得转发！！！

目录

  • 🎄一、概述
  • 🎄二、互斥量与信号量
    • ✨2.1 互斥量与信号量的相似之处
    • ✨2.2 互斥量与信号量的不同之处
  • 🎄三、信号量与条件变量
  • 🎄四、互斥量与条件变量
  • 🎄五、总结

在这里插入图片描述

🎄一、概述

在Linux系统多线程编程过程中，常常需要处理多个线程同步的问题。在处理多线程同步问题时，最常见的三种方式是：互斥量、信号量、条件变量，关于这三种方式的使用，在前面使用了四篇文章进行介绍和总结了，文章链接如下，感兴趣的自行取用：

【Linux C | 多线程编程】线程同步 | 互斥量(互斥锁)介绍和使用
【Linux C | 多线程编程】线程同步 | 条件变量(万字详解)
【Linux C | 多线程编程】线程同步 | 条件变量 的 使用总结
【Linux C | 多线程编程】线程同步 | 信号量(无名信号量) 及其使用例子

本文主要是对互斥量、信号量、条件变量三种使用方式的对比和总结，可以帮助我们对这三种线程同步方式的用法加深理解。

下文会经常提到临界区，所谓临界区，是指同一时间只能容许一个进程进入的一系列操作。

在这里插入图片描述

🎄二、互斥量与信号量

关于互斥量与信号量，比较形象的比喻是：互斥量是一间厕所，每次只允许一人访问； 信号量类似一个公共卫生间，里面的4间(多个)厕所，可以同时允许4个人访问。

互斥量的本质是一把锁，其作用是对临界区进行安全地访问(独占访问)，当多个线程访问临界区时，保证同一时刻只有一个线程访问临界区。互斥量有以下几个特点：
1、互斥量只有两种状态，已上锁、已解锁；
2、互斥量总是由给它上锁的线程解锁；
3、互斥量的访问方式是独占的，只有互斥量上锁了，其他线程就只能等待其访问完解锁，以此来保证一个时刻只有一个线程占有互斥量。

信号量是与某些资源相关联的，信号量初始化的信号量值表示资源个数。信号量值初始化为1则表示是二值信号量，若初始化的信号量值大于 1 则是计数信号量。信号量的特点如下：
1、二值信号量的取值只有两个：0、1；计数信号量的取值大于2个；
2、信号量可以在一个线程等待(减一)，另一个线程发布(加一)；也可以是同一个线程等待(减一)并发布(加一)。

✨2.1 互斥量与信号量的相似之处

互斥量和信号量有相同的地方，特别是二值信号量与互斥量甚至可以替换着使用，在Linux早期，就经历过将信号量替换成互斥量的过程，下图来源于网络，说明了这个替换过程：
在这里插入图片描述
比起互斥量，信号量先被设计和实现出来，且二值信号量可以起到互斥作用，所以早期的Linux代码使用了信号量来访问临界区。而互斥量最早是在2.6.16内核中由Red Hat Enterprise Linux的资深内核专家Ingo Molnar设计和实现的，之前的内核代码使用信号量也没有问题，但是互斥量在锁争用激烈的情况下，互斥量比信号量执行速度更快，可扩展性更好。

下面是使用互斥量访问临界区的示例代码：

// 08_mutex_test.c
// gcc 08_mutex_test.c -lpthread
#include <stdio.h>
#include <pthread.h>
#include <sys/syscall.h>
int g_Count = 0;
pthread_mutex_t g_mutex;
void *func(void *arg)
{
	int i=0;
	for(i=0; i<10000000; i++)
	{
		pthread_mutex_lock(&g_mutex);
		g_Count++;
		pthread_mutex_unlock(&g_mutex);
	}
	return NULL;
}

int main()
{
	pthread_mutex_init(&g_mutex, NULL);
	// 创建4个线程
	pthread_t threadId[4];
	int i=0;
	for(i=0; i<4; i++)
	{
		pthread_create(&threadId[i], NULL, func, NULL);
	}

	for(i=0; i<4; i++)
	{
		pthread_join(threadId[i],NULL);
		printf("join threadId=%lx\n",threadId[i]);
	}
	printf("g_Count=%d\n",g_Count);
	
	pthread_mutex_destroy(&g_mutex);
	
	return 0;
}

下面是使用信号量访问临界区的示例代码，可以与上一份代码对比，就可以知道互斥量和信号量的用于互斥时是相同的：

// 10_sem_mutex.c
// gcc 10_sem_mutex.c -l pthread
#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
int g_Count = 0;
sem_t g_sem;
void *func(void *arg)
{
	int i=0;
	for(i=0; i<10000000; i++)
	{
		sem_wait(&g_sem);
		g_Count++;
		sem_post(&g_sem);
	}
	return NULL;
}

int main()
{
	sem_init(&g_sem, 0, 1);
	// 创建4个线程
	pthread_t threadId[4];
	int i=0;
	for(i=0; i<4; i++)
	{
		pthread_create(&threadId[i], NULL, func, NULL);
	}

	for(i=0; i<4; i++)
	{
		pthread_join(threadId[i],NULL);
		printf("join threadId=%lx\n",threadId[i]);
	}
	printf("g_Count=%d\n",g_Count);
	
	sem_destroy(&g_sem);
	
	return 0;
}

✨2.2 互斥量与信号量的不同之处

互斥量与信号量的不同之处也很多，但主要的有两点：
1、互斥量总是在同一个线程加锁、解锁；信号量可以在一个线程等待(减一)，另一线程发布(加一)。
2、互斥量只有两个状态：已加锁、已解锁；信号量可以初始为大于1的值，与多个资源关联。

关于信号量可以在不同线程等待、发布的例子，决定在其与条件变量对比时在介绍。下面是信号量关联多个资源的例子：

// 10_sem_multiple.c
// gcc 10_sem_multiple.c -lpthread
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <semaphore.h>
#include <string.h>

#define  TOILET_NUM		4
#define  PEOPLE_NUM 	8

int 			toilets[TOILET_NUM] = {0,};		// 4个蹲厕
pthread_mutex_t toilet_mutex = PTHREAD_MUTEX_INITIALIZER;	// toilets 的互斥量
sem_t 			g_sem;

int getToilet()
{
	int i=0;
	for(i=0; i<TOILET_NUM; i++)
	{
		if(toilets[i] == 0)
			break;
	}
	return i;
}

int sem_value()
{
	int semvalue = 0;
	sem_getvalue(&g_sem, &semvalue);
	return semvalue;
}

// 上厕所线程
void *going_to_the_toilet(void *arg)
{
	int id = *((int*)arg);
	int count = 2;
	while(count-->0){
		printf("线程[%d] 等待厕所，厕所数量=%d\n",id, sem_value());
		sem_wait(&g_sem);
		pthread_mutex_lock(&toilet_mutex);	// 厕所有多个线程访问，加锁
		int i = getToilet();
		if(getToilet()==TOILET_NUM){
			printf("线程[%d], No toilet\n",id);
		}
		else{
			toilets[i] = 1;		// 表示进入该厕所
			printf("线程[%d] 进入厕所[%d], 即将工作 2s\n",id, i);
			pthread_mutex_unlock(&toilet_mutex); // 上厕所前先释放锁，让其他人可以访问厕所资源
			sleep(2);		// 正在上厕所...
			pthread_mutex_lock(&toilet_mutex);
			toilets[i] = 0;
			printf("线程[%d] 完成工作，厕所[%d]空闲\n",id, i);
		}
		pthread_mutex_unlock(&toilet_mutex);
		sem_post(&g_sem);
		sleep(1);	// 释放资源后，休眠1秒，确保资源让出去
	}
	return NULL;
}

int main()
{
	sem_init(&g_sem, 0, TOILET_NUM);// 初始化信号量值为4
	
	// 创建线程
	pthread_t people_thid[PEOPLE_NUM];
	int i=0, num[PEOPLE_NUM]={0,};
	for(i=0; i<PEOPLE_NUM; i++)
	{
		num[i] = i;
		pthread_create(&people_thid[i], NULL, going_to_the_toilet, &num[i]);
	}
	
	// 等待线程
	for(i=0; i<PEOPLE_NUM; i++)
	{
		pthread_join(people_thid[i], NULL);
	}
	
	sem_destroy(&g_sem);
	return 0;
}

运行结果这里就不展示了，可以看看上篇文章，关于信号量的。

在这里插入图片描述

🎄三、信号量与条件变量

条件变量用来阻塞一个线程，直到某条件满足为止。
信号量也可以使一个线程陷入阻塞(等待信号量)，直到另一个线程发布信号量。
仔细看上面两句话，分别描述了条件变量、信号量的功能，而且这两个功能看起来很类似，下面通过使用条件变量、信号量解决“生产者-消费者”的同步问题来了解条件变量、信号量使用上的区别。

下面是使用条件变量的代码：

// 09_producer_consumer_cond.c
// gcc 09_producer_consumer_cond.c -lpthread
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <string.h>
#include <errno.h>
#include "linux_list.h"

#define  COMSUMER_NUM	2

typedef struct _product
{
	struct list_head list_node;
	int product_id;
}product_t;

struct list_head productList;// 头结点
pthread_mutex_t product_mutex = PTHREAD_MUTEX_INITIALIZER;	// productList 的互斥量
pthread_cond_t  product_cond = PTHREAD_COND_INITIALIZER;	// 条件变量

// 生产者线程，1秒生成一个产品放到链表
void *th_producer(void *arg)
{
	int id = 0;
	while(1)
	{
		product_t *pProduct = (product_t*)malloc(sizeof(product_t));
		pProduct->product_id = id++;
		
		pthread_mutex_lock(&product_mutex);
		list_add_tail(&pProduct->list_node, &productList);
		pthread_cond_signal(&product_cond);
		pthread_mutex_unlock(&product_mutex);
		
		sleep(1);
	}
	
	return NULL;
}

// 消费者线程，1秒消耗掉一个产品
void *th_consumer(void *arg)
{
	while(1)
	{
		pthread_mutex_lock(&product_mutex);
		while(list_empty(&productList)) // 条件不满足
		{
			pthread_cond_wait(&product_cond, &product_mutex);
		}
		// 不为空，则取出一个
		product_t* pProduct = list_entry(productList.next, product_t, list_node);// 获取第一个节点
		printf("consumer[%d] get product id=%d\n", *((int*)arg), pProduct->product_id);
		list_del(productList.next); // 删除第一个节点
		free(pProduct);
		pthread_mutex_unlock(&product_mutex);
	}
	return NULL;
}

int main()
{
	INIT_LIST_HEAD(&productList);	// 初始化链表
	
	// 创建生产者线程
	pthread_t producer_thid;
	pthread_create(&producer_thid, NULL, th_producer, NULL);
	
	// 创建消费者线程
	pthread_t consumer_thid[COMSUMER_NUM];
	int i=0, num[COMSUMER_NUM]={0,};
	for(i=0; i<COMSUMER_NUM; i++)
	{
		num[i] = i;
		pthread_create(&consumer_thid[i], NULL, th_consumer, &num[i]);
	}
	
	// 等待线程
	pthread_join(producer_thid, NULL);
	for(i=0; i<COMSUMER_NUM; i++)
	{
		pthread_join(consumer_thid[i], NULL);
	}
	return 0;
}

下面是使用信号量的代码：

// 10_producer_consumer_sem.c
// gcc 10_producer_consumer_sem.c -lpthread
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <semaphore.h>
#include <string.h>
#include <errno.h>
#include "linux_list.h"

#define  COMSUMER_NUM	2

typedef struct _product
{
	struct list_head list_node;
	int product_id;
}product_t;

struct list_head productList;// 头结点
pthread_mutex_t product_mutex = PTHREAD_MUTEX_INITIALIZER;	// productList 的互斥量
sem_t 			g_sem;

// 生产者线程，1秒生成一个产品放到链表
void *th_producer(void *arg)
{
	int id = 0;
	while(1)
	{
		product_t *pProduct = (product_t*)malloc(sizeof(product_t));
		pProduct->product_id = id++;
		
		pthread_mutex_lock(&product_mutex);
		list_add_tail(&pProduct->list_node, &productList);
		pthread_mutex_unlock(&product_mutex);
		sem_post(&g_sem);
		
		sleep(1);
	}
	
	return NULL;
}

// 消费者线程，1秒消耗掉一个产品
void *th_consumer(void *arg)
{
	while(1)
	{
		pthread_mutex_lock(&product_mutex);
		while(list_empty(&productList)) // 条件不满足
		{
			pthread_mutex_unlock(&product_mutex);
			sem_wait(&g_sem);
			pthread_mutex_lock(&product_mutex);
		}
		// 不为空，则取出一个
		product_t* pProduct = list_entry(productList.next, product_t, list_node);// 获取第一个节点
		printf("consumer[%d] get product id=%d\n", *((int*)arg), pProduct->product_id);
		list_del(productList.next); // 删除第一个节点
		free(pProduct);
		pthread_mutex_unlock(&product_mutex);
	}
	return NULL;
}

int main()
{
	INIT_LIST_HEAD(&productList);	// 初始化链表
	sem_init(&g_sem, 0, 1);			// 初始化信号量
	
	// 创建生产者线程
	pthread_t producer_thid;
	pthread_create(&producer_thid, NULL, th_producer, NULL);
	
	// 创建消费者线程
	pthread_t consumer_thid[COMSUMER_NUM];
	int i=0, num[COMSUMER_NUM]={0,};
	for(i=0; i<COMSUMER_NUM; i++)
	{
		num[i] = i;
		pthread_create(&consumer_thid[i], NULL, th_consumer, &num[i]);
	}
	
	// 等待线程
	pthread_join(producer_thid, NULL);
	for(i=0; i<COMSUMER_NUM; i++)
	{
		pthread_join(consumer_thid[i], NULL);
	}
	
	sem_destroy(&g_sem);
	return 0;
}

运行结果是两份代码都可以使用“生产者-消费者”模式之间的线程同步，但有以下区别：
1、条件变量的等待函数要求传入互斥量作为参数，所以条件变量必须和互斥量同时使用；信号量没有类似的要求，虽然访问临界区时会用到互斥量，但这不是信号量要求的。
2、条件变量要求“①查询条件、②阻塞等待”是一个原子操作；信号量则允许“①查询条件、②阻塞等待”不是一个原子操作。

条件变量之所以要求“①查询条件、②阻塞等待”是一个原子操作，是因为判断条件和pthread_cond_wait之间被打断的话，可能在判断条件之后，调用pthread_cond_wait之前，条件变量就被唤醒了，导致该线程一直等待下去。

信号量之所以不需要要求“①查询条件、②阻塞等待”是一个原子操作，是因为它是计数的，如果判断完条件之后，调用sem_wait(&g_sem);之前，信号量发布(加一)了，那么调用sem_wait(&g_sem);时直接不需要等待，直接继续执行，不存在唤醒丢失的情况。总之，条件变量唤醒时如果没有线程等待在该条件变量上，那么信号将丢失；而信号量有计数值，每次信号量post操作都会被记录。

在这里插入图片描述

🎄四、互斥量与条件变量

互斥量与条件变量不像前面那样有相似的功能，更多的是互补的关系。

互斥量主要功能是使各个线程独占地访问临界区。
条件变量的功能是提供线程阻塞等待、其他线程唤醒的同步操作。但是没有提供安全访问临界区的功能，所以使用条件变量都需要互斥量一同使用。

在这里插入图片描述

🎄五、总结

👉本文总结了“互斥量与信号量使用的区别”、“信号量与条件变量使用的区别”、互斥量与条件变量的关系，并给出部分例子解析这些差异的存在。

在这里插入图片描述
如果文章有帮助的话，点赞👍、收藏⭐，支持一波，谢谢 😁😁😁

参考：
https://blog.csdn.net/tugouxp/article/details/68951576

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1610215.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【UKE！】2024.4.19

【UKE！】2024.4.19

2024.4.19 【你知道的都是真相。只可惜那些并不是真相的全部。】 Friday 三月十一 谷雨 <BGM “谷雨–音阙诗听”> AC :Answer Coarse,粗劣的答案 ​ CE :Compile Easily,轻松通过 ​ PC :Perfect Compile 完美的编译 ​ WA :Wonderful Answer,好答案 ​ RE :Run Exce…
阅读更多...
【Java开发指南 | 第十六篇】Java数组及Arrays类

【Java开发指南 | 第十六篇】Java数组及Arrays类

读者可订阅专栏&#xff1a;Java开发指南 |【CSDN秋说】 文章目录 数组数组特点创建数组处理数组多维数组Arrays类 数组 Java中的数组是一种用来存储固定大小的相同类型元素的数据结构。 数组特点 数组具有以下特点&#xff1a; 1、固定大小: 一旦数组被创建&#xff0c;其…
阅读更多...
【云计算】云数据中心网络（五）：对等连接

【云计算】云数据中心网络（五）：对等连接

《云网络》系列&#xff0c;共包含以下文章&#xff1a; 云网络是未来的网络基础设施云网络产品体系概述云数据中心网络&#xff08;一&#xff09;&#xff1a;VPC云数据中心网络&#xff08;二&#xff09;&#xff1a;弹性公网 IP云数据中心网络&#xff08;三&#xff09;…
阅读更多...
vue3 echarts 图表主题切换

vue3 echarts 图表主题切换

我主要是用了localStorage和composable来实现的。 先创建composable文件夹存储composable的操作方法&#xff1b; 在App.vue文件里面&#xff0c;先将主题数据存储在localStorage里面&#xff1b; 主题切换 图表theme包更换 为什么要用composable呢&#xff1f; 单纯的使用…
阅读更多...
CS61B sp21fall Project02 Gitlet

CS61B sp21fall Project02 Gitlet

Project02 Gitlet 一、项目简介二、Git和Gitlet2.1 Git简介2.2 Gitlet简介 三、框架设计3.1 Blobs3.2 Trees3.3 Commits 四、.Gitlet文件结构设计4.1 .git文件架构4.1.1 重点介绍index&#xff08;VSCode中无法查看&#xff0c;会乱码&#xff09;objects&#xff08;VSCode中无…
阅读更多...
【汇编语言】初识汇编

【汇编语言】初识汇编

【汇编语言】初识汇编 文章目录 【汇编语言】初识汇编前言由机器语言到汇编语言机器语言与机器指令汇编语言与汇编指令汇编语言程序示例 计算机组成指令和数据的表示计算机的存储单元计算机的总线 内存读写与地址空间CPU对存储器的读写内存地址空间 总结 前言 为什么要学习汇编…
阅读更多...
精通MongoDB聚合操作API：深入探索高级技巧与实践

精通MongoDB聚合操作API：深入探索高级技巧与实践

MongoDB 聚合操作API提供了强大的数据处理能力&#xff0c;能够对数据进行筛选、变换、分组、统计等复杂操作。本文介绍了MongoDB的基本用法和高级用法&#xff0c;高级用法涵盖了setWindowFields、merge、facet、expr、accumulator窗口函数、结果合并、多面聚合、查询表达式在…
阅读更多...
动态库静态库linux

动态库静态库linux

动态库静态库 静态库 静态库必须包含在可执行文件里&#xff0c;整个都要包含 缺点&#xff1a;消耗系统大&#xff0c;每个使用静态库的程序都要复制静态库&#xff08;浪费内存&#xff09; 影响使用场景&#xff1a; 在静态库内存小的时候&#xff0c;可以用来提升速度 制…
阅读更多...
Linux（CentOS7）离线使用安装盘部署Telnet

Linux（CentOS7）离线使用安装盘部署Telnet

# [pdf在线免费转word文档](https://orcc.online/pdf) https://orcc.online/pdf 挂载镜像CentOS-7-x86_64-DVD-1810.iso到/mnt下&#xff08;其他位置也行&#xff09;&#xff0c;命令如下&#xff1a; mount /dev/sr0 /mnt 安装包默认在Packages目录下&#xff0c;需要安装…
阅读更多...
【QT进阶】Qt Web混合编程之CMake VS2019编译并使用QCefView（图文并茂超详细版本）

【QT进阶】Qt Web混合编程之CMake VS2019编译并使用QCefView（图文并茂超详细版本）

往期回顾 【QT进阶】Qt Web混合编程之CEF、QCefView简单介绍-CSDN博客 【QT进阶】Qt Web混合编程之VS2019 CEF的编译与使用&#xff08;图文并茂超详细介绍&#xff09;-CSDN博客【QT进阶】Qt Web混合编程之QWebEngineView基本用法-CSDN博客【QT进阶】Qt Web混合编程之VS2019 C…
阅读更多...
AI生图美学在淘宝的实践应用

AI生图美学在淘宝的实践应用

本文介绍了如何制定和应用美学标准来评估和改善人工智能生成的图像质量&#xff0c;特别是在电商领域的应用&#xff0c;主要分为制定美学标准、训练美学模型、应用美学模型、升级淘宝风格模型四个步骤。 美学的定义与分析 图像质量标准&#xff1a;现代设计框架下&#xff0c;…
阅读更多...
类和对象【二】this指针，构造函数和成员初始化列表【超详细】

类和对象【二】this指针，构造函数和成员初始化列表【超详细】

文章目录 this指针this指针的定义this指针的“工作”原理this指针的作用this指针的特点 构造函数构造函数的定义构造函数的作用构造函数的特点构造函数的调用方式括号法无参构造或者全缺省构造需要传参才能调用的构造函数 隐式类型转换法是只传一个参数就能调用的构造函数是要传…
阅读更多...
HCIE-Shell实验1

HCIE-Shell实验1

要求&#xff1a; 判断当前磁盘剩余空间是否有20G&#xff0c;如果小于20G&#xff0c;则将报警邮件发送给管理员&#xff0c;每天检查一次磁盘剩余空间。判断web服务是否运行(1、査看进程的方式判断该程序是否运行&#xff0c;2、通过查看端口的方式判断该程序是否运行)&…
阅读更多...
大模型应用开发基础

大模型应用开发基础

AGI 时代&#xff0c;AI 无处不在&#xff0c;形成新的社会分层&#xff1a; AI 使用者&#xff0c;使用别人开发的 AI 产品AI 产品开发者&#xff0c;设计和开发 AI 产品基础模型相关&#xff0c;训练基础大模型&#xff0c;或为大模型提供基础设施 越向下层&#xff0c;重要…
阅读更多...
Leetcode-168.Excel表列名称

Leetcode-168.Excel表列名称

题目描述 给你一个整数 columnNumber &#xff0c;返回它在 Excel 表中相对应的列名称。 例如&#xff1a; A -> 1 B -> 2 C -> 3 ... Z -> 26 AA -> 27 AB -> 28 ...示例 1&#xff1a; 输入&#xff1a;columnNumber 1 输出&#xff1a;"A"…
阅读更多...
ROS2学习笔记（一） 基本概念

ROS2学习笔记（一） 基本概念

1. Node 节点 节点: 完成具体功能的模块 相关命令 #运行命令 ros2 run <package_name> <executable_name>#当前节点查询查询 ros2 node list#重映射　Remapping ros2 run <package_name> <executable_name> --ros-args --remap __node:<node_na…
阅读更多...
揭开ChatGPT面纱（一）：准备工作（搭建开发环境运行OpenAI Demo）

揭开ChatGPT面纱（一）：准备工作（搭建开发环境运行OpenAI Demo）

文章目录 序言&#xff1a;探索人工智能的新篇章一、搭建开发环境二、编写并运行demo1.代码2.解析3.执行结果 本博客的gitlab仓库&#xff1a;地址&#xff0c;本博客对应01文件夹。 序言&#xff1a;探索人工智能的新篇章 随着人工智能技术的飞速发展&#xff0c;ChatGPT作为…
阅读更多...
虚拟ip地址怎么弄到手机上

虚拟ip地址怎么弄到手机上

在当下的社会&#xff0c;手机已经变得至关重要&#xff0c;它融入了我们的日常生活&#xff0c;无论是上网冲浪、社交互动&#xff0c;还是工作学习&#xff0c;都离不开它。但有时候&#xff0c;由于某些限制&#xff0c;我们可能无法充分享受网络带来的便利。这时&#xff0…
阅读更多...
《苍穹外卖》Day02部分知识点记录

《苍穹外卖》Day02部分知识点记录

一、属性的拷贝以及密码的加密 使用org.springframework.beans中的BeanUtils.copyProperties()方法时&#xff0c;二者的属性名必须要一致。 /*** 新增员工* param employeeDTO*/Overridepublic void save(EmployeeDTO employeeDTO) {Employee employee new Employee();// 对…
阅读更多...
spring webflux 小结

spring webflux 小结

一、WebFlux 简介 WebFlux 是 Spring Framework5.0 中引入的一种新的反应式Web框架。通过Reactor项目实现Reactive Streams规范&#xff0c;完全异步和非阻塞框架。本身不会加快程序执行速度&#xff0c;但在高并发情况下借助异步IO能够以少量而稳定的线程处理更高的吞吐&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023