线程同步
1）所谓的同步并不是多个线程同时对内存进行访问，而是按照先后顺序依次进行的。
2）如没有对线程进行同步处理，会导致多个线程访问共享资源出现数据混乱的问题。
3）所谓共享资源就是多个线程共同访问的变量，这些变量通常为全局数据区变量或者堆区变量，这些变量对应的共享资源也被称之为临界资源。
4）常用的线程同步方式有四种：互斥锁、读写锁、条件变量、信号量。
5）通过锁机制能保证临界区代码最多只能同时有一个线程访问，这样并行访问就变为串行访问了。
互斥锁
1）通过互斥锁可以锁定一个代码块, 被锁定的这个代码块, 所有的线程只能顺序执行(不能并行处理)，需要付出的代价就是执行效率的降低。
1）一个互斥锁变量只能被一个线程锁定，被锁定之后其他线程再对互斥锁变量加锁就会被阻塞，直到这把互斥锁被解锁，被阻塞的线程才能被解除阻塞。
2）一般情况下，每一个共享资源对应一把互斥锁。
创建互斥锁
//在Linux中互斥锁的类型为pthread_mutex_t，创建一个这种类型的变量就得到了一把互斥锁：
pthread_mutex_t mutex;
// 初始化互斥锁
// restrict: 是一个关键字, 用来修饰指针, 只有这个关键字修饰的指针可以访问指向的内存地址, 其他指针是不行的
int pthread_mutex_init(pthread_mutex_t *restrict mutex,
const pthread_mutexattr_t *restrict attr);
参数:
mutex: 互斥锁变量的地址
attr: 互斥锁的属性, 一般使用默认属性即可, 这个参数指定为NULL
//函数调用成功会返回0，调用失败会返回相应的错误号：
加锁
// 修改互斥锁的状态, 将其设定为锁定状态, 这个状态被写入到参数 mutex 中
int pthread_mutex_lock(pthread_mutex_t *mutex);
这个函数被调用, 首先会判断参数 mutex 互斥锁中的状态是不是锁定状态
1）如果被锁定了, 其他线程加锁就失败了, 这些线程都会阻塞在这把锁上。
2）当这把锁被解开之后, 这些阻塞在锁上的线程就解除阻塞。
3）没抢到锁的线程继续阻塞。
// 尝试加锁
int pthread_mutex_trylock(pthread_mutex_t *mutex);
调用这个函数对互斥锁变量加锁还是有两种情况:
1）如果这把锁没有被锁定是打开的，线程加锁成功
2）如果锁变量被锁住了，调用这个函数加锁的线程，不会被阻塞，加锁失败直接返回错误号
解锁
// 对互斥锁解锁
int pthread_mutex_unlock(pthread_mutex_t *mutex);
1）不是所有的线程都可以对互斥锁解锁，哪个线程加的锁, 哪个线程才能解锁成功。
释放互斥锁
// 释放互斥锁资源
int pthread_mutex_destroy(pthread_mutex_t *mutex);
//函数调用成功会返回0，调用失败会返回相应的错误号：
死锁
1）锁使用不当, 就会造成死锁现象
2）线程死锁造成的后果是：使用这个共享资源的线程都被阻塞
造成死锁的场景有如下几种：
1）加锁之后忘记解锁。
2）重复加锁, 只解锁一次，造成死锁。
3）有多个共享资源, 两个线程交叉锁定了另一个线程的必要资源。
读写锁
读锁是共享的。写锁是独占的。
1）读写锁是互斥锁的升级版, 在做读操作的时候可以提高程序的执行效率。
2）读写锁是一把锁，可以做写锁定和读锁定两件事。
3）写锁的优先级高于****读锁。
创建读写锁
//在Linux中读写锁的类型为pthread_rwlock_t，创建一个这种类型的变量就得到了一把读写锁
pthread_rwlock_t rwlock;
在这把锁中大致记录了这些信息：
1）锁的状态: 锁定/打开。
2）锁定的是什么操作: 读操作/写操作，使用读写锁锁定了读操作，需要先解锁才能去锁定写操作。
3）哪个线程将这把锁锁上了。
// 初始化读写锁
int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,
const pthread_rwlockattr_t *restrict attr);
参数:
rwlock: 读写锁的地址，传出参数
attr: 读写锁属性，一般使用默认属性，指定为NULL
加读锁
// 对读写锁加读锁, 锁定的是读操作
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
// 尝试加读锁，调用这个函数加锁失败，对应的线程不会被阻塞，这个函数可以有效的避免死锁。
int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
// 如果加读锁失败, 不会阻塞当前线程, 直接返回错误号
加写锁
// 对读写锁加写锁, 锁定的是写操作
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
如果读写锁已经锁定了读操作或者锁定了写操作，调用这个函数的线程会被阻塞。
// // 尝试加写锁，调用这个函数加锁失败，对应的线程不会被阻塞，这个函数可以有效的避免死锁。
int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
// 如果加写锁失败, 不会阻塞当前线程, 直接返回错误号
//可以在程序中对函数返回值进行判断，添加加锁失败之后的处理动作。
解锁
// 解锁, 不管锁定了读还是写都可用解锁
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
释放读写锁
// 释放读写锁占用的系统资源
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
其他
如果说程序中所有的线程都对共享资源做写操作，使用读写锁没有优势，和互斥锁是一样的，
如果说程序中所有的线程都对共享资源有写也有读操作，并且对共享资源读的操作越多，读写锁更有优势。
条件变量
1）条件变量的主要作用不是处理线程同步, 而是进行线程的阻塞。
2）一般情况下条件变量用于处理生产者和消费者模型，并且和互斥锁配合使用。
创建条件变量
//条件变量类型为 pthread_cond_t，这样就定义一个条件变量类型的变量了
pthread_cond_t cond;
被条件变量阻塞的线程的线程信息会被记录到这个变量中，以便在解除阻塞的时候使用。
// 初始化条件变量
int pthread_cond_init(pthread_cond_t *restrict cond,
const pthread_condattr_t *restrict attr);
参数:
cond: 条件变量的地址
attr: 条件变量属性, 一般使用默认属性, 指定为NULL
阻塞线程
// 线程阻塞函数, 哪个线程调用这个函数, 哪个线程就会被阻塞
int pthread_cond_wait(pthread_cond_t *restrict cond, //条件变量
pthread_mutex_t *restrict mutex); //互斥锁
在阻塞线程的时候，需要一个互斥锁参数，这个互斥锁主要功能是进行线程同步
该函数会对这个互斥锁做以下几件事情：
1）在阻塞线程时候，如果线程已经对互斥锁mutex上锁，那么会将这把锁打开，这样做是为了避免死锁
2）当线程解除阻塞的时候，函数内部会帮助这个线程再次将这个mutex互斥锁锁上，继续向下访问临界区
// 表示的时间是从1971.1.1到某个时间点的时间, 总长度使用秒/纳秒表示
struct timespec {
time_t tv_sec; /* Seconds */
long tv_nsec; /* Nanoseconds [0 .. 999999999] */
};
// 将线程阻塞一定的时间长度, 时间到达之后, 线程就解除阻塞了
int pthread_cond_timedwait(pthread_cond_t *restrict cond, //条件变量
pthread_mutex_t *restrict mutex, //互斥锁
const struct timespec *restrict abstime);//表示线程阻塞的时长
struct timespec这个结构体中记录的时间是从1971.1.1到某个时间点的时间，总长度使用秒/纳秒表示。
time_t mytim = time(NULL); // 1970.1.1 0:0:0 到当前的总秒数
struct timespec tmsp;
tmsp.tv_sec = time(NULL) + 100; // 线程阻塞100s
tmsp.tv_nsec = 0;//初始化为0,避免出错
唤醒线程
// 唤醒阻塞在条件变量上的线程, 至少有一个被解除阻塞
int pthread_cond_signal(pthread_cond_t *cond);
// 唤醒阻塞在条件变量上的线程, 被阻塞的线程全部解除阻塞
int pthread_cond_broadcast(pthread_cond_t *cond);
1)调用上面两个函数中的任意一个，都可以唤醒被 pthread_cond_wait 或者 pthread_cond_timedwait 阻塞的线程，
2)区别就在于 pthread_cond_signal 是唤醒至少一个被阻塞的线程（总个数不定）， pthread_cond_broadcast 是唤醒所有被阻塞的线程。
释放条件变量
// 销毁释放资源
int pthread_cond_destroy(pthread_cond_t *cond);
信号量
创建信号量
//信号的类型为sem_t对应的头文件为<semaphore.h>
#include <semaphore.h>
sem_t sem;
// 初始化信号量/信号灯
int sem_init(sem_t *sem, int pshared, unsigned int value);
参数:
sem：信号量变量地址
pshared：
0：线程同步
非0：进程同步
value：初始化当前信号量拥有的资源数（>=0），如果资源数为0，线程就会被阻塞了。
判断 是否阻塞
// 函数被调用sem中的资源就会被消耗1个, 资源数-1
int sem_wait(sem_t *sem); //阻塞
1)sem中的资源数>0，线程不会阻塞，线程会占用sem中的一个资源，因此资源数-1，
2)直到sem中的资源数减为0时，资源被耗尽，因此线程也就被阻塞了。
// 函数被调用sem中的资源就会被消耗1个, 资源数-1
int sem_trywait(sem_t *sem); //不阻塞
1)并且sem中的资源数>0，线程不会阻塞，线程会占用sem中的一个资源，因此资源数-1，
2)直到sem中的资源数减为0时，资源被耗尽，但是线程不会被阻塞，直接返回错误号，
3)因此可以在程序中添加判断分支，用于处理获取资源失败之后的情况。
// 表示的时间是从1971.1.1到某个时间点的时间, 总长度使用秒/纳秒表示
struct timespec {
time_t tv_sec; /* Seconds */
long tv_nsec; /* Nanoseconds [0 .. 999999999] */
};
// 调用该函数线程获取sem中的一个资源，当资源数为0时，线程阻塞，在阻塞abs_timeout对应的时长之后，解除阻塞。
// abs_timeout: 阻塞的时间长度, 单位是s, 是从1970.1.1开始计算的
int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);
1)sem中的资源数>0，线程不会阻塞，线程会占用sem中的一个资源，因此资源数-1，
2)直到sem中的资源数减为0时，资源被耗尽，线程被阻塞，
3)当阻塞指定的 abs_timeout 时长之后，线程解除阻塞。
唤醒阻塞 线程
// 调用该函数给sem中的资源数+1
int sem_post(sem_t *sem);
1)该函数会将sem中的资源数+1，
2)如果有线程在调用 sem_wait、sem_trywait、sem_timedwait 时因为sem中的资源数为0被阻塞了，这时这些线程会解除阻塞，获取到资源之后继续向下运行。
获取现有可用资源数
// 查看信号量 sem 中的整形数的当前值, 这个值会被写入到sval指针对应的内存中
int sem_getvalue(sem_t *sem, int *sval);
// sval是一个传出参数
1)这个函数可以查看sem中现在拥有的资源个数，通过第二个参数 sval 将数据传出，
2)也就是说第二个参数的作用和返回值是一样的。
释放信号量
// 参数 sem 就是 sem_init() 的第一个参数
int sem_destroy(sem_t *sem);
// 资源释放, 线程销毁之后调用这个函数即可
其他
生产者和消费者 模型+案列
-------------------生产者消费者 案列(使用条件变量)-----------------------------
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>
// 链表的节点
struct Node
{
int number;
struct Node* next;
};
// 定义条件变量, 控制消费者线程
pthread_cond_t cond;
// 互斥锁变量
pthread_mutex_t mutex;
// 指向头结点的指针
struct Node * head = NULL;
// 生产者的回调函数
void* producer(void* arg)
{
// 一直生产
while(1)
{
pthread_mutex_lock(&mutex);
// 创建一个链表的新节点
struct Node* pnew = (struct Node*)malloc(sizeof(struct Node));
// 节点初始化
pnew->number = rand() % 1000;
// 节点的连接, 添加到链表的头部, 新节点就新的头结点
pnew->next = head;
// head指针前移
head = pnew;
printf("+++producer, number = %d, tid = %ld\n", pnew->number, pthread_self());
pthread_mutex_unlock(&mutex);
// 生产了任务, 通知消费者消费
pthread_cond_broadcast(&cond);
// 生产慢一点
sleep(rand() % 3);
}
return NULL;
}
// 消费者的回调函数
void* consumer(void* arg)
{
while(1)
{
pthread_mutex_lock(&mutex);
// 一直消费, 删除链表中的一个节点
// if(head == NULL) // 这样写有bug
while(head == NULL)
{
// 这函数会自动将线程拥有的锁解开
pthread_cond_wait(&cond, &mutex);
// 当消费者线程解除阻塞之后, 会自动将这把锁锁上
// 这时候当前这个线程又重新拥有了这把互斥锁
}
// 取出链表的头结点, 将其删除
struct Node* pnode = head;
printf("--consumer: number: %d, tid = %ld\n", pnode->number, pthread_self());
head = pnode->next;
free(pnode);
pthread_mutex_unlock(&mutex);
sleep(rand() % 3);
}
return NULL;
}
int main()
{
// 初始化条件变量
pthread_cond_init(&cond, NULL);
pthread_mutex_init(&mutex, NULL);
// 创建5个生产者, 5个消费者
pthread_t ptid[5];
pthread_t ctid[5];
for(int i=0; i<5; ++i)
{
pthread_create(&ptid[i], NULL, producer, NULL);
}
for(int i=0; i<5; ++i)
{
pthread_create(&ctid[i], NULL, consumer, NULL);
}
// 释放资源
for(int i=0; i<5; ++i)
{
// 阻塞等待子线程退出
pthread_join(ptid[i], NULL);
}
for(int i=0; i<5; ++i)
{
pthread_join(ctid[i], NULL);
}
// 销毁条件变量
pthread_cond_destroy(&cond);
pthread_mutex_destroy(&mutex);
return 0;
}
顺序执行的线程 案列
1)如果生产者和消费者线程使用的信号量对应的总资源数为1，那么不管线程有多少个，可以工作的线程只有一个，其余线程由于拿不到资源，都被迫阻塞了。
且不会出现生产者线程和消费者线程同时访问共享资源的情况，不管生产者和消费者线程有多少个，它们都是顺序执行的。(可不使用互斥锁)
----------------顺序执行的线程 案列------------------------------
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <semaphore.h>
#include <pthread.h>
// 链表的节点
struct Node
{
int number;
struct Node* next;
};
// 生产者线程信号量
sem_t psem;
// 消费者线程信号量
sem_t csem;
// 互斥锁变量
pthread_mutex_t mutex;
// 指向头结点的指针
struct Node * head = NULL;
// 生产者的回调函数
void* producer(void* arg)
{
// 一直生产
while(1)
{
// 生产者拿一个信号灯
sem_wait(&psem);
// 创建一个链表的新节点
struct Node* pnew = (struct Node*)malloc(sizeof(struct Node));
// 节点初始化
pnew->number = rand() % 1000;
// 节点的连接, 添加到链表的头部, 新节点就新的头结点
pnew->next = head;
// head指针前移
head = pnew;
printf("+++producer, number = %d, tid = %ld\n", pnew->number, pthread_self());
// 通知消费者消费, 给消费者加信号灯
sem_post(&csem);
// 生产慢一点
sleep(rand() % 3);
}
return NULL;
}
// 消费者的回调函数
void* consumer(void* arg)
{
while(1)
{
sem_wait(&csem);
// 取出链表的头结点, 将其删除
struct Node* pnode = head;
printf("--consumer: number: %d, tid = %ld\n", pnode->number, pthread_self());
head = pnode->next;
free(pnode);
// 通知生产者生成, 给生产者加信号灯
sem_post(&psem);
sleep(rand() % 3);
}
return NULL;
}
int main()
{
// 初始化信号量
// 生产者和消费者拥有的信号灯的总和为1
sem_init(&psem, 0, 1); // 生成者线程一共有1个信号灯
sem_init(&csem, 0, 0); // 消费者线程一共有0个信号灯
// 创建5个生产者, 5个消费者
pthread_t ptid[5];
pthread_t ctid[5];
for(int i=0; i<5; ++i)
{
pthread_create(&ptid[i], NULL, producer, NULL);
}
for(int i=0; i<5; ++i)
{
pthread_create(&ctid[i], NULL, consumer, NULL);
}
// 释放资源
for(int i=0; i<5; ++i)
{
pthread_join(ptid[i], NULL);
}
for(int i=0; i<5; ++i)
{
pthread_join(ctid[i], NULL);
}
sem_destroy(&psem);
sem_destroy(&csem);
return 0;
}
作者: 苏丙榅
链接: https://subingwen.cn/linux/thread-sync/?highlight=%E7%BA%BF%E7%A8%8B%E5%90%8C%E6%AD%A5
来源: 爱编程的大丙
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
详细教程可转
爱编程的大丙
