🚀同步互斥的概念
线程的互斥 - 指某一资源同时只允许一个访问者对其进行访问，具有唯一性和排它性。但互斥无法限制访问者对资源的访问顺序，即访问是无序的。
线程的同步 - 指在互斥的基础上（大多数情况），通过其它机制实现访问者对资源的有序访问。
当一个进程中存在多个线程且都要对该进程的某个全局变量进行访问，如果我们不进行人为干预的话那么可能就会乱套，那么我们要怎么解决这个问题呢——对临界区使用互斥量或者信号量
程序中，有时存在一种特殊代码，最多只允许一个线程执行该部分代码。
这部分区域，称为“临界区”
🍎信号量和互斥量的选择
对于同步和互斥，使用信号量或互斥量都可以实现。使用时，选择更符合语义的手段：
- 如果要求最多
只允许一个线程进入临界区，则使用互斥量 - 如果要求
多个线程之间的执行顺序满足某个约束，则使用信号量
其实互斥量就是信号量初值为1的体现！！
🎂信号量
头文件👇
#include <pthread.h>
#include <semaphore.h>
⭐什么是信号量
此时所指的“信号量”是指用于同一个进程内多个线程之间的信号量。即POSIX信号量，而不是System V信号量（用于进程之间的同步)，用于线程的信号量的原理，与用于进程之间的信号量的原理相同。都有P操作、V操作。
什么是P、V操作呢？
举个栗子：比如我现在手里有资源A，A的数量为1，P操作就等于我把资源A用掉，而V操作就等于我又产生了一个资源A，那么我就又可以接着使用资源A了，如果我们手上资源A已经没了我们还想用，那么就会阻塞，当产生资源A后我们才会继续使用资源A。
定义一个信号量：sem_t 信号量名
例：sem_t sem;
⭐信号量的使用
信号量的初始化
原型：int sem_init (sem_t *sem， int pshared, unsigned int value);
功能：对信号量进行初始化
参数：sem, 指向被初始化的信号量
pshared, 0：表示该信号量是该进程内使用的“局部信号量”， 不再被其它进程共享。非0：该信号量可被其他进程共享，Linux不支持这种信号量
value, 信号量的初值。>= 0
返回值：成功，返回0
失败， 返回错误码
信号量的P操作
原型：int sem_wait (sem_t *sem);
返回值：成功，返回0
失败， 返回错误码
信号量的V操作
原型：int sem_post (sem_t *sem);
返回值：成功，返回0
信号量的删除
原型：int sem_destroy (sem_t *sem);
返回值：成功，返回0
失败， 返回错误码
⭐信号量使用示例
1.创建2个线程（共有主线程、线程1、线程2共3个线程）
2.主线程阻塞式等待用户输入字符串
3.主线程每接收到一个字符串之后， 线程1就马上对该字符串进行处理。
4.线程1的处理逻辑为：统计该字符串的个数，并进行打印。
5.线程1把该字符串处理完后，线程2马上把当前时间进行打印
直到用户输入exit.
编译命令：
gcc mytest.c -D_REENTRANT -lpthread -o mytest.exe
mytest.c
#include <pthread.h>
#include <semaphore.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#define BUFF_SIZE 80
char buff[BUFF_SIZE];
//定义信号量
sem_t sem1;
sem_t sem2;
time_t now; //实例化time_t结构
struct tm *timenow; //实例化tm结构指针
//线程1执行的函数
void thread1_function(void*args)
{
printf("come to thread1_function!!\n");
while(1) {
//P(sem)
if (sem_wait(&sem1) != 0) {
printf("sem_wait sem1 failed!\n");
exit(1);
}
printf("string is: %slen=%d\n", buff, strlen(buff));
sem_post(&sem2);//对sem2进行v操作
if (strncmp(buff, "exit", 4) == 0) {
break;
}
}
}
//线程2执行的函数
void thread2_function(void*args)
{
printf("come to thread2_function!!\n");
while(1)
{
//P(sem)
if (sem_wait(&sem2) != 0) {
printf("sem_wait sem2 failed!\n");
exit(1);
}
time(&now);
//localtime函数把从time取得的时间now换算成你电脑中的时间(就是你设置的地区)
timenow = localtime(&now);
//asctime函数把时间转换成字符，通过printf()函数输出
printf("Local time is %s\n",asctime(timenow));
if (strncmp(buff, "exit", 4) == 0) {
break;
}
}
}
int main()
{
//创建两个子线程
pthread_t mythread1;
pthread_t mythread2;
int ret;
void* returnP;
//初始化信号量
ret = sem_init(&sem1, 0, 0);
if(ret != 0)
{
printf("init sem1 failed!!!\n");
exit(1);
}
ret = sem_init(&sem2, 0, 0);
if(ret != 0)
{
printf("init sem2 failed!!!\n");
exit(1);
}
//创建线程
ret = pthread_create(&mythread1,0,thread1_function,0);
if(ret != 0)
{
printf("create thread 1 failed!!\n");
exit(1);
}
ret = pthread_create(&mythread2,0,thread2_function,0);
if(ret != 0)
{
printf("create thread 2 failed!!\n");
exit(1);
}
printf("come to while!!\n");
while(1)
{
fgets(buff,sizeof(buff),stdin);
if(sem_post(&sem1)!=0)
{
printf("sem_post sem1 failed!!\n");
exit(1);
}
if (strncmp(buff, "exit", 4) == 0) {
break;
}
}
//单纯为了等待两个线程结束
pthread_join(mythread1,&returnP);
pthread_join(mythread2,&returnP);
//销毁信号量
if(sem_destroy(&sem1)||sem_destroy(&sem2))
{
printf("destroy sem failed!!!\n");
exit(1);
}
printf("destroy sem success!!!\n");
return 0;
}
运行结果:
🐝互斥量
⭐什么是互斥量
效果上等同于初值为1的信号量
定义一个互斥量：pthread_mutex_t 互斥量名;
例：pthread_mutex_t myMutex;
⭐互斥量的使用
互斥量的初始化
原型：int pthread_mutex_init(pthread_mutex_t *mutex,
pthread_mutexattr_t *attr);
参数：mutex， 指向被初始化的互斥量
attr, 指向互斥量的属性一般取默认属性（当一个线程已获取互斥量后，该线程再次获取该信号量，将导致阻塞!)
返回值：成功返回0
互斥量的获取（相当于P操作）
原型：int pthread_mutex_lock (pthread_mutex_t *mutex);
互斥量的释放（相当于V操作）
原型：int pthread_mutex_unlock (pthread_mutex_t *mutex);
互斥量的删除
原型：int pthread_mutex_destroy (pthread_mutex_t *mutex);
⭐互斥量使用示例
该实例中会产生一个子线程，两个线程同时对全局变量globel_value进行减减操作并且将globel_value数值进行打印，我们想要的理想情况应该是交替输出globel_value的值且输出的值都不一样
不加互斥量的情况会出现👇
以下是加入了互斥量的代码：
编译命令：gcc mutex.c -D_REENTRANT -lpthread -o mymutex.exe
mutex.c
#include <pthread.h>
#include <semaphore.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#define BUFF_SIZE 80
int global_value = 1000;
pthread_mutex_t lock;
static void* str_thread_handle(void *arg)
{
int i = 0;
for (i=0; i<10; i++) {
pthread_mutex_lock(&lock);
if (global_value > 0) {
// work
sleep(1);
printf("soled ticket(%d) to ChildStation(%d)\n",
global_value, i+1);
}
global_value--;
pthread_mutex_unlock(&lock);
sleep(1);
}
}
int main(void)
{
int ret;
pthread_t str_thread;
void *thread_return;
int i;
ret = pthread_mutex_init(&lock, 0);
if (ret != 0) {
printf("pthread_mutex_init failed!\n");
exit(1);
}
ret = pthread_create(&str_thread, 0, str_thread_handle, 0);
if (ret != 0) {
printf("pthread_create failed!\n");
exit(1);
}
for (i=0; i<10; i++) {
pthread_mutex_lock(&lock);
if (global_value > 0) {
// work
sleep(1);
printf("soled ticket(%d) to MainStation(%d)\n",
global_value, i+1);
}
global_value--;
pthread_mutex_unlock(&lock);
sleep(1);
}
ret = pthread_join(str_thread, &thread_return);
if (ret != 0) {
printf("pthread_join failed!\n");
exit(1);
}
ret = pthread_mutex_destroy(&lock);
if (ret != 0) {
printf("pthread_mutex_destroy failed!\n");
exit(1);
}
return 0;
}
运行结果：
🌰总结
信号量和互斥量都是对线程间的同步和互斥进行服务，而互斥量其实可以看作就是信号量的一种特殊情况（初始值为1），合理地运用信号量和互斥量可以让多个线程有条不紊的执行你想要的效果，希望这篇文章能够对您有所帮助，也非常感谢您能够看到这😀
扫一扫
730
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
