1.同步
1.1概念
同步(synchronization)指的是多个任务(线程)按照约定的顺序相互配合完成一件事情
(异步：异步则反之，并非一定需要一件事做完再做另一件事。）
1.2同步机制
通过信号量实现线程间同步。
信号量：通过信号量实现同步操作；由信号量来决定线程是继续运行还是阻塞等待.
信号量代表某一类资源，其值表示系统中该资源的数量:
信号量的值>0,表示有资源可以用, 可以申请到资源,
信号量的值<=0, 表示没有资源可以通用, 无法申请到资源, 阻塞.
信号量还是一个受保护的变量，只能通过三种操作来访问：初始化、Ｐ操作(申请资源)、Ｖ操作(释放资源)
1.3函数接口
sem_t 信号量; 定义信号量
sem_init: 信号量初始化
sem_wait: 申请资源,P操作, 如果没有资源可以用, 阻塞, -1
sem_post: 释放资源,V操作, 非阻塞 +1
int sem_init( sem_t *sem, int pshared, unsignedint value)
功能：初始化信号量
参数：sem：初始化的信号量对象
pshared：信号量共享的范围( 0 : 线程间使用 非0 :1进程间使用)
value：信号量初值
返回值：成功 0
失败 -1
int sem_wait( sem_t *sem)
功能：申请资源 P操作
参数：sem：信号量对象
返回值：成功 0
失败 -1
注：此函数执行过程，当信号量的值大于0时，表示有资源可以用，则继续执行，同时对信号量减1；当信号量的值等于0时，表示没有资源可以使用，函数阻塞
int sem_post( sem_t *sem)
功能：释放资源 V操作
参数：sem：信号量对象
返回值：成功 0
失败 -1
注：释放一次信号量的值加1，函数不阻塞
2.互斥
2.1概念
互斥：多个线程在访问临界资源时，同一时间只能一个线程访问
临界资源：一次仅允许一个线程所使用的资源
临界区：指的是一个访问共享资源的程序片段
互斥锁：通过互斥锁可以实现互斥机制，主要用来保护临界资源，每个临界资源都由一个互斥锁来保护，线程必须先获得互斥锁才能访问临界资源，访问完资源后释放该锁。如果无法获得锁，线程会阻塞直到获得锁为止。
2.2函数接口
pthread_mutex_t lock; // 申请锁
pthread_mutex_init； // 初始化锁
pthread_mutex_lock；// 上锁
pthread_mutex_unlock；// 解锁
int pthread_mutex_init( pthread_mutex_t *mutex, pthread_mutexattr_t *attr)
功能：初始化互斥锁
参数：mutex：互斥锁
attr: 互斥锁属性 // NULL表示缺省属性
返回值：成功 0
失败 -1
int pthread_mutex_lock( pthread_mutex_t *mutex)
功能：申请互斥锁
参数：mutex：互斥锁
返回值：成功 0
失败 -1、
注：和 pthread_mutex_trylock 区别：
pthread_mutex_lock 是阻塞的；
pthread_mutex_trylock 不阻塞，如果申请不到锁会立刻返回
int pthread_mutex_unlock( pthread_mutex_t *mutex)
功能：释放互斥锁
参数：mutex：互斥锁
返回值：成功 0
失败 -1
int pthread_mutex_destroy( pthread_mutex_t *mutex)
功能：销毁互斥锁
参数：mutex：互斥锁
2.3死锁
是指两个或两个以上的进程或线程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。
死锁产生的四个必要条件
1、互斥使用，即当资源被一个线程使用(占有)时，别的线程不能使用
2、不可抢占，资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放。
3、请求和保持，即当资源请求者在请求其他的资源的同时保持对原有资源的占有。
4、 循环等待，即存在一个等待队列：P1占有P2的资源，P2占有P3的资源，P3占有P1的资源。这样就形成了一个等待环路。
注意：当上述四个条件都成立的时候，便形成死锁。当然，死锁的情况下如果打破上述任何一个条件，便可让死锁消失。
3.条件变量
条件变量用于在线程之间传递信号，以便某些线程可以等待某些条件发生。当某些条件发生时，条件变量会发出信号，使等待该条件的线程可以恢复执行。
一般和互斥锁搭配使用，实现同步机制:
pthread_cond_t cond; // 申请条件变量
pthread_cond_init(&cond,NULL); //初始化条件变量
使用前需要上锁：
pthread_mutex_lock(&lock); //上锁
判断条件
pthread_cond_wait(&cond, &lock); //阻塞等待条件产生，没有条件产生时阻塞，同时解锁，当条件产生时结束阻塞，再次上锁
pthread_cond_signal(&cond); //产生条件，不阻塞
pthread_cond_destroy(&cond); //销毁条件变量
注意： 必须保证让pthread_cond_wait先执行，pthread_cond_signal再产生条件
4.练习一
通过线程实现数据的交互，主线程循环从终端输入，线程函数将数据循环输出，当输入quit结束程序。
4.1全局变量写法
#include <stdio.h>
#include <pthread.h>
#include <string.h>
char buf[32] = "";
int flag = 0;
// 定义全局变量，用于线程间通信
// 当flag为0时，调度到子线程，不运行，调度到 主线程时，进行输入并且flag 变为1
// 当flag为1时，调度到主线程，不运行，调度到 从线程时，进行输出并且flag 变为0
void *handler_thread(void *arg)
{
while (1)
{
if (flag == 1)
{
// 当在主线程输入完之后，flag变为 1;
// 满足从线程条件，当调度从线程时，就可以进行输出，
// 输出完之后flag变为0，不满足从线程，满足主线程，调度到主线程时就进行输入
if (strcmp(buf, "quit") == 0)
{
break;
}
printf("%s\n", buf);
flag = 0;
}
}
return NULL;
}
int main(int argc, char const *argv[])
{
pthread_t tid;
int n = pthread_create(&tid, NULL, handler_thread, NULL);
if (n != 0)
{
perror(" creat thread error");
return -1;
}
while (1)
{
if (flag == 0)
{
scanf("%s", buf);
// 输入完之后，flag 改为1;不满足下次循环，
// 只有当输出字符串之后，flag 变为 0 之后，满足 主线程条件，进行输入
flag = 1;
if (strcmp(buf, "quit") == 0)
{
break;
}
}
}
return 0;
}
4.2信号量写法
#include <stdio.h>
#include <pthread.h>
#include <string.h>
#include <semaphore.h>
#include <unistd.h>
// 通过两个信号量,
// 当sem1为1时.从线程可以申请到资源进行输出,当sem1为0时进入阻塞,等待主线程输入
// 当sem2为1时,主线程可以进行输入,当sem2为0时进入阻塞,等待从线程进行输出
char buf[32] = "";
// 定义信号量
sem_t sem1;
sem_t sem2;
void *handler_thread(void *arg)
{
while (1)
{
// 申请资源,sem1 为1时申请成功,之后sem1变为0;
// sem1为0时申请失败进入阻塞
sem_wait(&sem1);
if (strcmp(buf, "quit") == 0)
{
break;
}
printf("%s\n", buf);
// 输出完成,释放资源,sem2变为1,
sem_post(&sem2);
}
return NULL;
}
int main(int argc, char const *argv[])
{
// 初始化信号量
if (sem_init(&sem1, 0, 0) != 0)
{
perror("sem1 init err");
return -1;
}
if (sem_init(&sem2, 0, 1) != 0)
{
perror("sem init err");
return -1;
}
pthread_t tid;
int n = pthread_create(&tid, NULL, handler_thread, NULL);
if (n != 0)
{
perror(" creat thread error");
return -1;
}
while (1)
{
// 申请资源,sem2 为1时申请成功,之后sem2变为0;
// sem1为0时申请失败进入阻塞
sem_wait(&sem2);
scanf("%s", buf);
if (strcmp(buf, "quit") == 0)
{
break;
}
// 输出完成,释放资源,sem1变为1,
sem_post(&sem1);
}
return 0;
}
5.练习二
请在linux 利用c语言编程实现两个线程按照顺序依次输出”ABABABAB......" (信雅达)
例如a线程输出”A”之后b线程输出”B”，然后a线程输出“A”，再b线程输出”B”，之后往复循环。
5.1信号量写法
#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
#include <unistd.h>
// 利用信号量实现两个线程按照顺序一次输出ABABABAB
// 信号量
sem_t sem1;
sem_t sem2;
void *outa(void *arg)
{
while (1)
{
sleep(1);
// 申请资源，初始sem2信号量为1,a运行，
// 输出A 之后，sem2 变为 0
// 如果sem2为0, a阻塞
sem_wait(&sem2);
printf("A");
// 输出A 之后，释放资源，sem1变为1
sem_post(&sem1);
}
}
void *outb(void *arg)
{
while (1)
{
sleep(1);
// 申请资源，初始sem1信号量为0,b阻塞，
// 如果sem1为1, b运行
// 输出完B 之后，sem1 变为
sem_wait(&sem1);
printf("B ");
// 输出 B 之后，释放资源，sem2变为1
sem_post(&sem2);
putchar('\n');
}
}
int main(int argc, char const *argv[])
{
// 线程标识
pthread_t tid1, tid2;
// 初始化信号量
sem_init(&sem1, 0, 0);
sem_init(&sem2, 0, 1);
// 创建线程并判断
if (pthread_create(&tid1, NULL, outa, NULL) != 0)
{
perror("tid1 err");
return -1;
}
if (pthread_create(&tid2, NULL, outb, NULL) != 0)
{
perror("tid2 err");
return -1;
}
// 回收线程
pthread_join(tid1, NULL);
pthread_join(tid2, NULL);
return 0;
}
5.2互斥锁加条件变量写法
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
// 利用互斥所与条件变量实现两个线程按照顺序一次输出ABABABAB
// 定义全局条件变量与锁，条件变量用于线程间通信
pthread_mutex_t lock;
pthread_cond_t cond;
void *funA(void *arg)
{
for (int i = 0; i < 10; i++)
{
sleep(2);
pthread_mutex_lock(&lock); // 上锁
printf("A");
fflush(NULL); // 刷新
pthread_cond_signal(&cond); // 发信号，此时线程b可以输出b
pthread_mutex_unlock(&lock); // 解锁
}
pthread_exit(NULL);
}
void *funB(void *arg)
{
for (int i = 0; i < 10; i++)
{
pthread_mutex_lock(&lock); // 上锁
// 请求条件，没有条件时阻塞，等待线程a发出信号后，解除阻塞
pthread_cond_wait(&cond, &lock);
printf("B ");
fflush(NULL);
pthread_mutex_unlock(&lock);
}
putchar('\n');
pthread_exit(NULL);
}
int main(int argc, char const *argv[])
{
// 线程标识
pthread_t tid1, tid2;
// 初始化条件变量
pthread_cond_init(&cond, NULL);
// 创建线程
if (pthread_create(&tid1, NULL, funA, NULL) < 0)
{
perror("tid1 err");
return -1;
}
if (pthread_create(&tid2, NULL, funB, NULL) < 0)
{
perror("tid1 err");
return -1;
}
// 初始化互斥锁
pthread_mutex_init(&lock, NULL);
// 判断互斥锁是否初始化成功
if (pthread_mutex_init(&lock, NULL) != 0)
{
perror(" init error");
return -1;
}
// 回收线程
pthread_join(tid1, NULL);
pthread_join(tid2, NULL);
return 0;
}