(꒪ꇴ꒪ )，Hello我是祐言QAQ
我的博客主页：C/C++语言，数据结构，Linux基础，ARM开发板，网络编程等领域UP🌍
快上🚘，一起学习，让我们成为一个强大的攻城狮！
送给自己和读者的一句鸡汤🤔：集中起来的意志可以击穿顽石!
作者水平很有限，如果发现错误，请在评论区指正，感谢🙏

在并发编程中，线程安全是一个重要的问题。多个线程并发访问共享数据时，如果没有正确的同步机制，可能会导致数据的不一致，从而引发错误。为了保证线程安全，我们需要使用多种同步机制，如信号量，互斥锁，读写锁和条件变量等。

但总结起来就一句话：控制多个线程对同一块资源访问的限制，以保证线程安全！

一、POSIX信号量

信号量是一种广泛使用的同步机制，可以用来实现多种同步需求，如互斥，同步，计数等，在此前我们也对其进行了学习，其本质就是用P/V操作来对资源进行控制。

1. 有名信号量

有名信号量是一种可以跨进程使用的信号量。就是在创建信号量时，需要给信号量指定一个名字，其他进程或线程可以通过这个名字来打开并操作这个信号量。

#include <fcntl.h>
#include <sys/stat.h>
#include <semaphore.h>
        sem_t *sem_open(const char *name, int oflag);        // 创建或者打开一个有名信号量

#include <semaphore.h>
        int sem_wait(sem_t *sem); // P 操作
        int sem_post(sem_t *sem); // V 操作
        int sem_close(sem_t *sem); // 关闭

  int sem_unlink(sem_t *sem);        // 删除，并释放系统资源

下面就举一个例子来演示这些函数的用法，使用了 有名信号量来实现了线程间的同步和互斥，确保两个线程能够交替地访问共享资源 t 而不会发生竞争条件：

posixname.c

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <semaphore.h>

#define SPACE "/my_space"  // 使用唯一的路径名
#define DATA "/my_data"

sem_t *space;
sem_t *data;

int t = 0;

//线程任务函数1
void *task1(void *arg)
{	
	while(1)
	{
		sem_wait(space);//P操作   空间资源-1
		
		printf("线程任务函数1执行任务 t = %d\n", t);
		sleep(1);
		t++;
		sem_post(data);//V操作    数据资源+1
	}
}

//线程任务函数2
void *task2(void *arg)
{	
	while(1)
	{
		sem_wait(data);//P操作    数据资源-1

		printf("线程任务函数2执行任务 t = %d\n", t);
		sleep(1);
		t++;
		sem_post(space);//V操作   空间资源+1
	}
}

int main(int argc, char const *argv[])
{
	// 删除已存在的同名信号量（如果有的话）
	sem_unlink(SPACE);
	sem_unlink(DATA);

	// 打开有名信号量
	space = sem_open(SPACE, O_CREAT, 0777, 1);
	data = sem_open(DATA, O_CREAT, 0777, 0);

	pthread_t pid1;
	pthread_t pid2;
	pthread_create(&pid1, NULL, task1, NULL);
	pthread_create(&pid2, NULL, task2, NULL);

	while(1);

	return 0;
}

2.无名信号量

无名信号量只在进程内部可见，不需要通过文件系统或路径来标识，也是线程间共享资源的一种常用方式。

我们首先在内部线程都能访问到的区域定义这种变量（比如全局变量），类型是 sem_t。同样使用 sem_wait( )/sem_trywait( )和 sem_post( )来分别进行 P、V 操作，不再需要时，使用 sem_destroy( )来销毁他。

其API接口为：

#include <semaphore.h>

int sem_init(sem_t *sem, int pshared, unsigned int value);

举个例子，交叉让线程1和2分别显示 t 的值：

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <semaphore.h>

sem_t space;  // 空间信号量，用于控制线程1访问空间
sem_t data;   // 数据信号量，用于控制线程2访问数据
int t = 1;

// 线程任务函数1
void *task1(void *arg)
{	
	while(1)
	{
		sem_wait(&space);  // 等待空间信号量减1，P操作，空间资源-1
		
		printf("线程任务函数1执行任务 t = %d\n", t);
		sleep(1);
		sem_post(&data);   // 发送数据信号量加1，V操作，数据资源+1
	}
}

// 线程任务函数2
void *task2(void *arg)
{	
	while(1)
	{
		sem_wait(&data);   // 等待数据信号量减1，P操作，数据资源-1

		printf("线程任务函数2执行任务 t = %d\n", t);
		sleep(1);
		sem_post(&space);  // 发送空间信号量加1，V操作，空间资源+1
	}
}

int main(int argc, char const *argv[])
{
	// 初始化信号量，空间信号量初始值为1，数据信号量初始值为0
	sem_init(&space, 0, 1);
	sem_init(&data, 0, 0);

	pthread_t pid1;
	pthread_t pid2;
	pthread_create(&pid1, NULL, task1, NULL); // 创建线程1
	pthread_create(&pid2, NULL, task2, NULL); // 创建线程2

	while(1);  // 主线程无限循环，保持程序运行

	return 0;
}

二、互斥锁

互斥锁确保在任何给定时刻只有一个线程可以访问共享资源，从而避免了多个线程同时修改数据导致的数据不一致性问题。这就像你去网吧上网，当你打开001号机子的时候，只有你可以坐在那里玩耍，如果别人想玩001号机器，只有等你走。

互斥锁的主要特点包括：

加锁与解锁：线程在访问共享资源之前必须先获得互斥锁，称为加锁操作，而在完成对共享资源的操作后，需要释放锁，称为解锁操作。这样可以确保只有一个线程在任意时刻持有锁，其他线程必须等待。这好比你在001号机器上登录了你的账号，别人就不能登录，只有等你退出以后才可以由他人来登录。
互斥性：互斥锁确保只有一个线程可以持有锁，其他线程必须等待，以保证共享资源的独占性。这就好比001号机器只有一个人可以玩，无论是谁。
阻塞与非阻塞：互斥锁可以以阻塞或非阻塞的方式使用。在阻塞模式下，如果一个线程尝试获取已经被其他线程持有的锁，它会被阻塞，直到锁可用。在非阻塞模式下，线程会立即返回，而不会等待锁。这里有一个地方值得强调一下，锁一般是成对出现的，最好不要让他进入阻塞，否则很容易死锁。

pthread_mutex_t m;         // 定义一个互斥锁变量

函数原型：
        pthread_mutex_init(&m, NULL);        //初始化
        pthread_mutex_lock(&m);                //上锁
        pthread_mutex_unlock(&m); //解锁
        pthread_mutex_destroy(&m);        //销毁锁

下面我们就使用互斥锁来重现一下刚才的例子，循环访问t并使之加1，只不过这次使用的是互斥锁：

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <semaphore.h>

//定义一个互斥锁变量
pthread_mutex_t m;

int t = 0;

//退出处理例程函数
void func(void *arg)
{
	pthread_mutex_unlock(&m);	//解锁（释放资源）
}

//线程任务函数1
void *task1(void *arg)
{	
	//压栈退出处理例程函数
	pthread_cleanup_push(func, NULL);
	while(1)
	{
		
		pthread_mutex_lock(&m);	//加锁（申请资源）

		printf("线程任务函数1执行任务 t = %d\n", t);
		sleep(1);
		t++;
		pthread_mutex_unlock(&m);	//解锁（释放资源）
		usleep(10);
	}
	//弹栈退出处理例程函数
	pthread_cleanup_pop(-1);
}

//线程任务函数2
void *task2(void *arg)
{	
	//压栈退出处理例程函数
	pthread_cleanup_push(func, NULL);
	while(1)
	{
		
		pthread_mutex_lock(&m);	//加锁（申请资源）

		printf("线程任务函数2执行任务 t = %d\n", t);
		sleep(1);
		t++;
		pthread_mutex_unlock(&m);	//解锁（释放资源）
		usleep(10);
	}
	//弹栈退出处理例程函数
	pthread_cleanup_pop(-1);
}

int main(int argc, char const *argv[])
{
	//初始化互斥锁变量
	pthread_mutex_init(&m, NULL);

	pthread_t pid1,pid2;
	pthread_create(&pid1, NULL, task1, NULL);
	pthread_create(&pid2, NULL, task2, NULL);

	while(1);

	return 0;
}

互斥锁在以下使用过程中容易出现死锁：

（1）某个线程上锁过后，在没有解锁的时候就被异常杀死，那么需要获取同一个锁的其他线程会卡死；

（2）当多个线程交替上锁解锁2个锁的时候，有可能出现死锁。

 	pthread_mutex_lock(&m1);//上锁
	printf("做一件2s的事情\n");
	sleep(2);
	pthread_mutex_lock(&m2);//上锁
	pthread_mutex_unlock(&m1); //解锁

因此我们在使用互斥锁时要注意：

（1）为线程创建取消例程，释放有可能没有释放的锁；

（2）尽量避免在一组上锁解锁过程中，再次上锁同一把锁或其他锁；

（3）互斥锁保护的临界区不要太长，也不要嵌套太多函数。临界区是上一篇博客中讲到的一个概念，你可以理解为它指的就是使用互斥锁的程序段。

三、读写锁

读写锁大致与互斥锁相同，但是允许多个线程同时读共享数据，又只允许一个线程写共享数据的同步机制。这就好像，大家在KTV唱歌，为了又更好的体验，每次只能一个人开口唱歌（写数据），但是话筒却有很多把（读数据），这样方便大家随时接唱。

static pthread_rwlock_t rwlock        ;//定义读写锁

函数原型：
        pthread_rwlock_init(&rwlock,NULL);        //初始化读写锁
        pthread_rwlock_rdlock(&rwlock);        //读锁，可以多次上锁
        pthread_rwlock_wrlock(&rwlock);        //写锁，一次只能一个
        pthread_rwlock_unlock(&rwlock);        //解锁
        pthread_rwlock_destroy(&rwlock);        //销毁锁

这一次我们换个花样，由线程1来做输入端，而线程2和3都是读端，首先读到的是 t = 0（初始定义的），然后我们可通过写锁来修改 t 值，再次读显示。这里要强调一下，线程 2 和 3 的运行顺序并不是人为规定的，而是由他们自己抢锁造成的，也许多运行几次 2 会出现在 3 的前面，其实 1也在抢锁，这就是阻塞与非阻塞的体现。

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <semaphore.h>

//定义读写锁变量      读写锁在线程之间，存在一个竞争，线程会去抢这个锁资源的
pthread_rwlock_t rwlock;

int t = 0;

//线程任务函数1    写操作
void *task1(void *arg)
{	
	while(1)
	{
		//加读锁（一次可以加多个）   阻塞：跟写锁抢锁资源    跟读锁抢锁资源，不会阻塞
		pthread_rwlock_wrlock(&rwlock);
		printf("线程1输入：\n");
		scanf("%d", &t);
		//解锁
		pthread_rwlock_unlock(&rwlock);
		
		usleep(10);
	}	
}


//线程任务函数2   读操作
void *task2(void *arg)
{	
	while(1)
	{
		//加读锁（一次可以加多个）   阻塞：跟写锁抢锁资源    跟读锁抢锁资源，不会阻塞
		pthread_rwlock_rdlock(&rwlock);

		printf("线程任务函数2执行任务 t = %d\n", t);
		sleep(1);

		pthread_rwlock_unlock(&rwlock);

		usleep(10);
	}
}

//线程任务函数3   读操作
void *task3(void *arg)
{	
	while(1)
	{
		//加读锁（一次可以加多个）
		pthread_rwlock_rdlock(&rwlock);

		printf("线程任务函数3执行任务 t = %d\n", t);
		sleep(1);

		pthread_rwlock_unlock(&rwlock);	
		usleep(10);
	}	
}

int main(int argc, char const *argv[])
{
	//初始化读写锁
	pthread_rwlock_init(&rwlock,NULL);

	pthread_t pid1;
	pthread_t pid2;
	pthread_t pid3;
	pthread_create(&pid1, NULL, task1, NULL);
	pthread_create(&pid2, NULL, task2, NULL);
	pthread_create(&pid3, NULL, task3, NULL);

	while(1);

	return 0;
}

四、条件变量

条件变量是多线程编程中的一种同步机制，通常与互斥锁（Mutex）一起使用，用于线程之间的协调和通信，并防止条件检查和条件等待之间的竞态条件。条件变量允许一个或多个线程在特定条件下等待，并在条件满足时被唤醒，从而实现线程的协同工作。下面就举一个张三张四两兄弟取钱的例子来帮助大家更好的理解条件变量的使用：

张三和张四准备去取生活费，但是每次只能进去一个人去ATM取钱，张三进去后想取200元，但是一查发现没钱，就打电话询问父母，这时候等着也无聊还要把位置让出来给别人取，因此张三走出ATM柜台，进入了等待队列，此时张四很急，一下冲进去结果发现也没钱，于是也灰溜溜进入了等待队列，过了一会，父母打电话告诉他们钱已经到账了，于是他们又分别进去取钱，取到后就走了。

那么条件变量到底是啥呢，在这个例子中，条件变量就是起到告知父母传话的作用，为什么要这么做呢，因为你不可能一直在ATM机器前来回刷新你的卡，别人也还要用，这样很占用资源，线程也是，如果一个线程一直在来回访问一个数据，你让别的线程如何工作调用这个数据，搞不好还要死锁或崩溃，因此在多线程访问时用上条件变量就会使线程间有序访问，做到同步。

下面呢就来看一下这个例子如何用代码实现：

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <semaphore.h>

pthread_cond_t cond;
pthread_mutex_t m;

//共享资源   钱
int money = 0;

//线程任务函数1    张三    取钱200
void *task1(void *arg)
{
	//先上锁
	pthread_mutex_lock(&m);	//加锁

	while(money<200)	//取钱的时候，发现钱不够
	{
		//进入条件变量等待队列，做了解锁操作，然后等待通知，有通知来了之后，又会 加锁去取钱
		pthread_cond_wait(&cond, &m);
		printf("张三收到通知去取钱，发现不够，继续等\n");
	}
	//上面这个循环退出，相当于钱余额够的
	money-=200;
	printf("张三取走两百\n");
	printf("余额：%d\n", money);

	pthread_mutex_unlock(&m);	//解锁

}

//线程任务函数2    张四    取钱300
void *task2(void *arg)
{
	//先上锁
	pthread_mutex_lock(&m);	//加锁
	
	while(money<300)	//取钱的时候，发现钱不够
	{
		//进入条件变量等待队列，做了解锁操作，然后等待通知，有通知来了之后，又会 加锁去取钱
		pthread_cond_wait(&cond, &m);
		printf("张四收到通知去取钱，发现不够，继续等\n");
	}
	//上面这个循环退出，相当于钱余额够的
	money-=300;
	printf("张四取走三百\n");
	printf("余额：%d\n", money);

	pthread_mutex_unlock(&m);	//解锁
}

int main(int argc, char const *argv[])//主线程    比作张三跟张四的父母
{
	//初始化条件变量
	pthread_cond_init(&cond, NULL);
	//初始化互斥锁
	pthread_mutex_init(&m, NULL);

	pthread_t pid1;
	pthread_t pid2;
	pthread_create(&pid1, NULL, task1, NULL);
	pthread_create(&pid2, NULL, task2, NULL);

	int mon;
	while(1)
	{
		printf("请输入存钱的金额：\n");
		scanf("%d", &mon);
		money += mon;
		printf("余额：%d\n", money);
		//通知张三跟张四取钱，广播唤醒
		pthread_cond_broadcast(&cond);
		usleep(1000);
	}

	return 0;
}

注意：

在调用 pthread_cond_wait 之前，必须先获得 mutex 的锁。
函数执行后，会自动将 mutex 的锁释放，等待被唤醒后会重新获取该锁。
如果多个线程在等待同一个条件变量，当调用 pthread_cond_signal 或 pthread_cond_broadcast 时，它们中的一个或多个线程将会被唤醒。
通常需要将 pthread_cond_wait 放在一个循环中，以防止虚假唤醒（spurious wakeups）。这意味着即使没有明确的信号，线程也可能会被唤醒，因此需要重新检查条件。

五、几种线程安全机制的比较

1.信号量：信号量是一种灵活的线程同步机制，可以用于控制多个线程的访问，通过P/V操作来减少或增加信号量的值。信号量适用于各种同步场景，但需要小心使用，避免死锁或竞态条件。

2.互斥锁：互斥锁是最常见的线程同步机制，用于保护临界资源，确保同一时刻只有一个线程可以访问。互斥锁容易使用，但要注意锁的粒度和避免死锁。

3.读写锁：读写锁允许多个线程同时读取共享资源，但只允许一个线程写入。这在读多写少的场景中很有用，可以提高并发性能。但也需要小心处理写锁升级和读锁降级，以避免死锁。

4.条件变量：条件变量通常与互斥锁一起使用，它允许线程等待某个条件满足后才继续执行。这对于需要等待特定事件发生的情况非常有用，避免了忙等待。但需要小心使用，确保条件的正确性和避免死锁。

总的来说，选择哪种线程安全机制取决于具体的应用场景和需求。每种机制都有其优势和限制，了解它们的特性并根据情况选择合适的机制是编写多线程程序的关键。此外，良好的设计和编码实践也是确保线程安全的重要因素，包括合理的锁粒度、避免死锁、异常处理等。也就是正确使用这些机制，可以有效地解决多线程并发访问共享数据的问题，保证线程安全。

更多C/C++语言、Linux系统、数据结构和ARM板实战相关文章，关注专栏：

手撕C语言

玩转linux

脚踢数据结构

系统、网络编程

探索C++

6818（ARM）开发板实战