互斥锁和信号量

一、同步互斥概述

• 在多任务操作系统中，同时运行的多个任务可能都需要访问/使用同一种资源 多个任务之间有依赖关系，某个任务的运行依赖于另一个任务
  同步和互斥就是用于解决这两个问题的。

• 互斥:一个公共资源同一时刻只能被一个进程或线程使用，多个进程或线程不能同时使用公共资源。POSIX标准中进程和线程同步和互斥的方法,主要有信号量和互斥锁两种方式。

• 同步:两个或两个以上的进程或线程在运行过程中协同步调，按预定的先后次序运行。 同步就是在互斥的基础上有顺序

二、互斥锁

2.1 互斥锁的概念
mutex是一种简单的加锁的方法来控制对共享资源的访问，mutex只有两种状态,即上 锁(lock)和解锁(unlock)。 在访问该资源前，首先应申请mutex，如果mutex处于unlock状态，则会申请到 mutex并立即lock； 如果mutex处于lock状态，则默认阻塞申请者。 unlock操作应该由lock者进行。

2.2 互斥锁的操作
包含头文件：#include <pthread.h>
参数：mutex：互斥锁地址。
返回值： 成功：0 失败：非0
（1）初始化互斥锁
mutex用pthread_mutex_t数据类型表示，在使用互斥锁前,必须先对它进行初始化，一般将互斥锁定义为全局变量。

静态分配的互斥锁：
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
动态分配互斥锁:
pthread_mutex_t mutex; pthread_mutex_init(&mutex, NULL);

在所有使用过此互斥锁的线程都不再需要使用时候，应调用pthread_mutex_destroy销毁互斥锁。

（2） 互斥锁上锁
int pthread_mutex_lock(pthread_mutex_t *mutex);
功能：对互斥锁上锁，若已经上锁，则调用者一直阻塞到互斥锁解锁

int pthread_mutex_trylock(pthread_mutex_t *mutex);
功能：对互斥锁上锁，若已经上锁，则上锁失败，函数立即返回。

（3） 互斥锁解锁
int pthread_mutex_unlock(pthread_mutex_t * mutex);
功能：对指定的互斥锁解锁。

（4） 销毁互斥锁
int pthread_mutex_destroy(pthread_mutex_t *mutex);
功能：销毁指定的一个互斥锁。

死锁的理解
死锁就是两个线程各自占有1个资源，但又在彼此等待对方释放锁。

代码案例：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>

//通过互斥锁解决线程间互斥问题

int money = 10000;

//第一步：创建互斥锁(由于两个线程操作同一个互斥锁，所以定义在全局更加方便一点)
pthread_mutex_t mymutex;

void *pthread_fun1(void *arg)
{
    int get, yu, shiji;
    get = 10000;
    
    //第三步：对共享资源的操作进行上锁
    pthread_mutex_lock(&mymutex);

    printf("张三正在查询余额...\n");
    sleep(1);
    yu = money;

    printf("张三正在取钱...\n");
    sleep(1);
    if(get > yu)
    {
        shiji = 0;
    }
    else 
    {
        shiji = get;
        yu = yu - get;
        money = yu;
    }

    printf("张三想取%d元，实际取了%d元，余额为%d元\n", get, shiji, yu);

    //第四步：当共享资源的操作执行完毕后，对互斥锁执行解锁操作
    pthread_mutex_unlock(&mymutex);

    pthread_exit(NULL);
}

void *pthread_fun2(void *arg)
{
    int get, yu, shiji;
    get = 10000;

    //第三步：对共享资源的操作进行上锁
    pthread_mutex_lock(&mymutex);
    
    printf("李四正在查询余额...\n");
    sleep(1);
    yu = money;

    printf("李四正在取钱...\n");
    sleep(1);
    if(get > yu)
    {
        shiji = 0;
    }
    else 
    {
        shiji = get;
        yu = yu - get;
        money = yu;
    }

    printf("李四想取%d元，实际取了%d元，余额为%d元\n", get, shiji, yu);

    //第四步：当共享资源的操作执行完毕后，对互斥锁执行解锁操作
    pthread_mutex_unlock(&mymutex);

    pthread_exit(NULL);
}

int main(int argc, char const *argv[])
{
    //第二步：初始化互斥锁
    pthread_mutex_init(&mymutex, NULL);

    pthread_t thread1, thread2;

    if(pthread_create(&thread1, NULL, pthread_fun1, NULL) != 0)
    {
        perror("fail to pthread_create");
        exit(1);
    }

    if(pthread_create(&thread2, NULL, pthread_fun2, NULL) != 0)
    {
        perror("fail to pthread_create");
        exit(1);
    }

    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

    //第五步：当互斥锁使用完毕后，要销毁
    pthread_mutex_destroy(&mymutex);
    
    return 0;
}

执行结果：

三、信号量

3.1 信号量的概念

• 信号量广泛用于进程或线程间的同步和互斥，信号量本质上是一个非负的整数计数器， 它被用来控制对公共资源的访问。
• 编程时可根据操作信号量值的结果判断是否对公共资源具有访问的权限，当信号量值大于０时，则可以访问，否则将阻塞。
• 对信号量的操作又称之为PV操作，ＰＶ原语是对信号量的操作，一次Ｐ操作使信号量sem减１，一次Ｖ操作使信号量sem加１，对于P操作，如果信号量的sem值为等于0，则P操作就会阻塞，如果信号量的值大于0，才可以执行P操作进行减1

信号量主要用于进程或线程间的同步和互斥这两种典型情况。
1、若用于互斥，几个进程（或线程）往往只设置一个信号量。
2、若用于同步操作，往往会设置多个信号量，并且安排不同的初始值，来实现它们之间的 执行顺序。

信号量用于互斥

信号量用于同步

3.2 对信号量的基本操作
包含头文件：#include <semaphore.h>
返回值：成功返回 0，失败返回-1。
（1） 信号量的初始化
int sem_init(sem_t *sem, int pshared,unsigned int value);
功能：创建一个信号量并初始化它的值。
参数：

• sem：信号量的地址。
• pshared：等于 0，信号量在线程间共享；不等于 0，信号量在进程间共享。
• value：信号量的初始值。

（2） 信号量 P 操作
int sem_wait(sem_t *sem);
功能：将信号量的值减 1，若信号量的值小于等于 0，此函数会引起调用者阻塞。
参数：sem：信号量地址。

int sem_trywait(sem_t *sem);
功能：将信号量的值减 1，若信号量的值小于等于 0，则对信号量的操作失败，函数立即返回。
参数：sem：信号量地址。

（3） 信号量的 V 操作
int sem_post(sem_t *sem);
功能：将信号量的值加 1 并发出信号唤醒等待线程。
参数：sem：信号量地址。

（4） 获取信号量的计数值
int sem_getvalue(sem_t *sem, int *sval);
功能： 获取 sem 标识的信号量的值，保存在 sval 中。
参数：

• sem：信号量地址。
• sval：保存信号量值的地址。

（5） 信号量的销毁
int sem_destroy(sem_t *sem);
功能：删除 sem 标识的信号量。
参数：sem：信号量地址。

代码案例1：信号量实现互斥功能

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <semaphore.h>

//通过信号量实现互斥操作

//第一步：创建一个信号量
sem_t sem;

void printer(char *str)
{
    //第三步：执行P操作
    //由于使用信号量实现互斥，信号量的初始值设置为1，则两个线程执行P操作，
    //先执行P操作的线程继续执行，后执行P操作的先阻塞等待
    sem_wait(&sem);
	while(*str)
	{
		putchar(*str);	
		fflush(stdout);
		str++;
		sleep(1);
	}
    //第四步：执行V操作
    sem_post(&sem);
}

void *thread_fun1(void *arg)
{
	char *str1 = "hello";
	printer(str1);
}

void *thread_fun2(void *arg)
{
	char *str2 = "world";
	printer(str2);
}

int main(void)
{
    //第二步：初始化信号量
    sem_init(&sem, 0, 1);

	pthread_t tid1, tid2;
	
	pthread_create(&tid1, NULL, thread_fun1, NULL);
	pthread_create(&tid2, NULL, thread_fun2, NULL);
	
	pthread_join(tid1, NULL);
	pthread_join(tid2, NULL); 

    printf("\n");
    
    //第五步：使用完毕后销毁信号量
    sem_destroy(&sem);

	return 0;
}

执行结果：

代码案例2：信号量实现同步功能

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>

//使用信号量实现同步功能，如果两个线程实现同步，需要通过两个信号量

char ch = 'a';

//第一步：创建两个信号量
sem_t sem_g, sem_p;

void * pthread_g(void *arg) 
{
	while(1)
	{
        //第四步：后执行的线程中，信号量的初始值设置为0的信号量执行P操作
        sem_wait(&sem_g);

		ch++;
		sleep(1);

        //第六步：后执行的线程执行完毕后，信号量初始值为1的信号量执行V操作
        sem_post(&sem_p);
	}
}
void * pthread_p(void *arg)  //此线程打印ch的值
{
	while(1)
	{
        //第三步：先执行的线程中，信号量初始值设置为1的信号量执行P操作
        sem_wait(&sem_p);

		printf("%c",ch);
		fflush(stdout);

        //第五步：当先执行的线程执行完毕后，信号量初始值为0的信号量执行V操作
        sem_post(&sem_g);
	}
}

int main(int argc, char *argv[])
{
    //初始化信号量
    sem_init(&sem_g, 0, 0);
    sem_init(&sem_p, 0, 1);

	pthread_t tid1,tid2;
	
	pthread_create(&tid1,NULL,pthread_g,NULL);
	pthread_create(&tid2,NULL,pthread_p,NULL);
	
	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);

    printf("\n");

    //第七步：使用完毕后销毁信号量
    sem_destroy(&sem_g);
    sem_destroy(&sem_p);

	return 0;
}

执行结果：