linux-线程间同步互斥回顾

线程间同步互斥的操作：

1、线程间同步    ==== 有序执行

    1、多个信号量

    2、条件变量+互斥锁  ===>broadcast signal

2、线程间互斥  ==== "你死我活"

    1、单个信号量

    2、互斥锁

同步和互斥是为了什么？

    为了保护临界资源

什么是临界资源：

    全局变量

        pthread_create之前的成为 全局资源 =====>当有线程操作全局资源的时候 ===>变为临界资源

 //多个信号量实现同步，有序执行
#include<stdio.h>
#include <pthread.h>
#include <semaphore.h>


#define N 64
typedef struct message
{
	char buf[N];
	int len;
}msg_t;

sem_t sem_reverse;//两个信号量 逆置信号量
sem_t sem_printf;//打印信号量

void* reverse_msgbuf(void* arg)
{
	msg_t* msg = (msg_t*)arg;
	int i = 0;
	char tmp;
	while (1)
	{
		sem_wait(&sem_reverse);//P操作，上锁资源数-1
		printf("reverse_msgbuf -------------\n");
		//printf("hello reverse_msgbuf.\n");
#if 1
		for (i = 0; i < msg->len / 2; i++)
		{
			tmp = msg->buf[i];
			msg->buf[i] = msg->buf[msg->len - i - 1];
			msg->buf[msg->len - i - 1] = tmp;
		}
#endif 
		sleep(1);
		printf("reverse_msgbuf :%s\n", msg->buf);
		sem_post(&sem_printf);//V操作打印的信号量+1
	}
}

void* printf_msgbuf(void* arg)
{
	msg_t* msg = (msg_t*)arg;
	while (1)
	{
		sem_wait(&sem_printf);
		printf("printf_msgbuf :***********\n");
		printf("printf_msgbuf :%s\n", msg->buf);
		sem_post(&sem_reverse);
	}
}

int main(int argc, const char* argv[])
{
	msg_t msg = { "123456789",9 };
	pthread_t tid[2];
	//信号量初始化 逆置先执行 打印后执行
	sem_init(&sem_reverse, 0, 1);
	sem_init(&sem_printf, 0, 0);
	//创建两个线程
	pthread_create(&tid[0], NULL, reverse_msgbuf, (void*)&msg);
	pthread_create(&tid[1], NULL, printf_msgbuf, (void*)&msg);
	//pause函数是一个系统调用，作用是使当前进程挂起，直到接收到一个信号。当调用pause函数时，当前进程会进入睡眠状态，直到收到一个信号。一旦有信号到达，进程会被信号中断唤醒，并且pause函数返回-1，同时设置errno为EINTR（表示被信号中断）。
	//pause函数通常用于在程序中创建一个无限循环，以等待某个特定信号的到来。通过挂起进程的方式，可以避免空轮询占用过多的资源。一旦接收到指定的信号，程序可以执行相应的处理逻辑。
	//	需要注意的是，由于信号的到达是异步的，所以在调用pause函数之前应该设置好对应信号的处理函数，以防止信号被忽略或默认处理。否则，如果信号到达时没有对应的处理函数或者设置为默认处理，pause函数可能会使进程永久地挂起。
	pause();

	return 0;
}

   

 ************************************************************************/
 //互斥锁实现互斥的过程，只有一把锁是无序的
#include<stdio.h>
#include <pthread.h>

#define N 64
typedef struct message
{
	char buf[N];
	int len;
}msg_t;

pthread_mutex_t mymutex;

void* reverse_msgbuf(void* arg)
{
	msg_t* msg = (msg_t*)arg;
	int i = 0;
	char tmp;
	while (1)
	{
		pthread_mutex_lock(&mymutex);
		for (i = 0; i < msg->len / 2; i++)
		{
			tmp = msg->buf[i];
			msg->buf[i] = msg->buf[msg->len - i - 1];
			msg->buf[msg->len - i - 1] = tmp;
		}
		pthread_mutex_unlock(&mymutex);
	}
}

void* printf_msgbuf(void* arg)
{
	msg_t* msg = (msg_t*)arg;
	while (1)
	{
		pthread_mutex_lock(&mymutex);
		printf("buf :%s\n", msg->buf);
		pthread_mutex_unlock(&mymutex);
		sleep(1);
	}
}

int main(int argc, const char* argv[])
{
	msg_t msg = { "123456789",9 };

	pthread_t tid[2];
	pthread_mutex_init(&mymutex, NULL);

	pthread_create(&tid[0], NULL, reverse_msgbuf, (void*)&msg);
	pthread_create(&tid[1], NULL, printf_msgbuf, (void*)&msg);

	pause();

	return 0;
}

   

 ************************************************************************/
 //条件变量 条件变量+互斥锁  ===>broadcast signal 实现有序同步
#include<stdio.h>
#include <pthread.h>

#define N 64
typedef struct message
{
	char buf[N];
	int len;
	//	int busy_flag;
}msg_t;

int flag = 0;
pthread_mutex_t mymutex;
pthread_cond_t mycond = PTHREAD_COND_INITIALIZER;

void* reverse_msgbuf(void* arg)
{
	msg_t* msg = (msg_t*)arg;
	int i = 0;
	char tmp;
	while (1)
	{
		pthread_mutex_lock(&mymutex);
		printf("reverse_msgbuf -------------\n");
		while (flag != 0)
		{
			pthread_cond_wait(&mycond, &mymutex);//1、判断条件是否满足，满足向下执行，不满足则释放锁
		}
		//printf("hello reverse_msgbuf.\n");
#if 1
		for (i = 0; i < msg->len / 2; i++)
		{
			tmp = msg->buf[i];
			msg->buf[i] = msg->buf[msg->len - i - 1];
			msg->buf[msg->len - i - 1] = tmp;
		}
#endif 
		printf("reverse_msgbuf :%s\n", msg->buf);
		flag = 1;
		pthread_mutex_unlock(&mymutex);//释放锁
		pthread_cond_broadcast(&mycond);//条件也释放掉
	}
}

void* printf_msgbuf(void* arg)
{
	msg_t* msg = (msg_t*)arg;
	while (1)
	{
		pthread_mutex_lock(&mymutex);
		printf("printf_msgbuf :***********\n");
		while (flag != 1)
		{
			pthread_cond_wait(&mycond, &mymutex);
		}
		printf("printf_msgbuf :%s\n", msg->buf);
		flag = 0;
		pthread_mutex_unlock(&mymutex);
		pthread_cond_broadcast(&mycond);
	}
}

int main(int argc, const char* argv[])
{
	//msg_t msg = {"123456789",9,0};
	msg_t msg = { "123456789",9 };

	pthread_t tid[2];
	//初始化条件变量和互斥锁
	pthread_cond_init(&mycond, NULL);
	pthread_mutex_init(&mymutex, NULL);

	pthread_create(&tid[0], NULL, reverse_msgbuf, (void*)&msg);
	pthread_create(&tid[1], NULL, printf_msgbuf, (void*)&msg);

	pause();

	return 0;
}

   

 ************************************************************************/
 //多个条件变量一把锁实现有序执行同步互斥
#include<stdio.h>
#include <pthread.h>

#define N 64
typedef struct message
{
	char buf[N];
	int len;
	//	int busy_flag;
}msg_t;

pthread_mutex_t mymutex;
//两个条件变量
pthread_cond_t mycond_reverse = PTHREAD_COND_INITIALIZER;
pthread_cond_t mycond_printf = PTHREAD_COND_INITIALIZER;

void* reverse_msgbuf(void* arg)
{
	msg_t* msg = (msg_t*)arg;
	int i = 0;
	char tmp;
	while (1)
	{
		pthread_mutex_lock(&mymutex);
		pthread_cond_wait(&mycond_reverse, &mymutex);
		printf("reverse_msgbuf -------------\n");
#if 1
		for (i = 0; i < msg->len / 2; i++)
		{
			tmp = msg->buf[i];
			msg->buf[i] = msg->buf[msg->len - i - 1];
			msg->buf[msg->len - i - 1] = tmp;
		}
#endif 
		printf("reverse_msgbuf :%s\n", msg->buf);
		pthread_mutex_unlock(&mymutex);
	}
}

void* printf_msgbuf(void* arg)
{
	msg_t* msg = (msg_t*)arg;
	while (1)
	{
		pthread_mutex_lock(&mymutex);
		pthread_cond_wait(&mycond_printf, &mymutex);
		printf("printf_msgbuf :***********\n");
		printf("printf_msgbuf :%s\n", msg->buf);
		pthread_mutex_unlock(&mymutex);
	}
}

int main(int argc, const char* argv[])
{
	//msg_t msg = {"123456789",9,0};
	msg_t msg = { "123456789",9 };

	pthread_t tid[2];

	pthread_cond_init(&mycond_printf, NULL);
	pthread_cond_init(&mycond_reverse, NULL);
	pthread_mutex_init(&mymutex, NULL);

	pthread_create(&tid[0], NULL, reverse_msgbuf, (void*)&msg);
	pthread_create(&tid[1], NULL, printf_msgbuf, (void*)&msg);

	while (1)
	{
		pthread_cond_signal(&mycond_printf);//发送信号通知mycond_printf条件满足
		sleep(1);
		pthread_cond_signal(&mycond_reverse);
		sleep(1);
	}

	pause();

	return 0;
}