在多任务操作系统中，同时运行的多个任务可能都需要访问/使用同一种资源 多个任务之间有依赖关系，某个任务的运行依赖于另一个任务
同步和互斥就是用于解决这两个问题的。
互斥:一个公共资源同一时刻只能被一个进程或线程使用，多个进程或线程不能同时使用公共资源。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 信号量的概念
信号量主要用于进程或线程间的同步和互斥这两种典型情况。
1、若用于互斥，几个进程（或线程）往往只设置一个信号量。
2、若用于同步操作，往往会设置多个信号量，并且安排不同的初始值，来实现它们之间的 执行顺序。
信号量用于互斥
信号量用于同步
3.2 对信号量的基本操作
包含头文件：#include <semaphore.h>
返回值：成功返回 0，失败返回-1。
（1） 信号量的初始化
int sem_init(sem_t *sem, int pshared,unsigned int 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 中。
参数：
（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;
}
执行结果：
