linux-多任务同步和互斥

---

同步互斥概述

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

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

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

互斥锁

互斥锁的概念

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

互斥锁的操作

初始化互斥锁
mutex用pthread_mutex_t数据类型表示，在使用互斥锁前,必须先对它进行初始化。

静态分配的互斥锁
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

动态分配互斥锁
pthread_mutex_t mutex;
pthread_mutex_init(&mutex, NULL);
在所有使用过此互斥锁的线程都不再需要使用时候，应调用pthread_mutex_destroy销毁 互斥锁。

初始化互斥锁

互斥锁上锁

互斥锁解锁

销毁互斥锁

互斥锁案例

不使用互斥锁的结果

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
int money = 10000;
void *pthread_fun1(void *arg)
{
    int get, yu, shiji;
    get = 10000;
    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_exit(NULL);
}
void *pthread_fun2(void *arg)
{
    int get, yu, shiji;
    get = 10000;
    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_exit(NULL);
}
int main(int argc, char const *argv[])
{
    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);
    return 0;
}

使用互斥锁的结果

#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;
}

信号量

信号量的概念

信号量广泛用于进程或线程间的同步和互斥，信号量本质上是一个非负的整数计数器，它被用来控制对公共资源的访问。
编程时可根据操作信号量值的结果判断是否对公共资源具有访问的权限，当信号量值大于０时，则可以访问，否则将阻塞。
信号量又称之为PV操作，ＰＶ原语是对信号量的操作，一次Ｐ操作使信号量sem减 １，一次Ｖ操作使信号量sem加１，对于P操作，如果信号量的sem值为小于等于0，则P操作就会阻塞，如果信号量的值大于0，才可以执行P操作进行减1。
信号量主要用于进程或线程间的同步和互斥这两种典型情况
1、若用于互斥，几个进程（或线程）往往只设置一个信号量。
2、若用于同步操作，往往会设置多个信号量，并且安排不同的初始值，来实现它们之间的执行顺序。

信号量用于互斥

信号量用于同步

信号量的操作

信号量的初始化

信号量P操作

信号量V操作

获得信号量的计数值

信号量的销毁

信号量的使用

信号量实现互斥功能

#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;
}

一秒打印一个字符，先打印完hello接着是world

信号量实现同步功能

#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;
}