线程同步（互斥锁、读写锁、条件变量、信号量）
互斥锁、读写锁、条件变量、信号量
阮一峰解释进程和线程：
进程与线程的简单解释 - 阮一峰的网络日志 (ruanyifeng.com)
一、什么是线程同步？
线程同步并不是多个线程同时对内存进行访问，而是按照先后顺序依次进行访问，线程同步 == 线程排队。
二、为什么要线程同步？
例子：两个线程A和B在运行时需要分时复用CPU时间片，如果线程A执行这个过程期间就失去了CPU时间片，线程A被挂起了最新的数据没能更新到物理内存。线程B变成运行态之后从物理内存读数据，很显然它没有拿到最新数据，只能基于旧的数据执行，然后失去CPU时间片挂起。线程A得到CPU时间片变成运行态，第一件事儿就是将上次没更新到内存的数据更新到内存，但是这样会导致线程B已经更新到内存的数据被覆盖，线程B的活儿白干。
三、线程同步方法：互斥锁、读写锁、条件变量、信号量
3.1 临界区
找到临界资源之后，再找和临界资源相关的上下文代码，这样就得到一个代码块，这个代码块可以称之为临界区。
① 在临界区代码的上边，添加加锁函数，对临界区加锁：
哪个线程调用这句代码，就会把这把锁锁上，其他线程就只能阻塞在锁上了。
② 在临界区代码的下边，添加解锁函数，对临界区解锁：
出临界区的线程会将锁定的那把锁打开，其他抢到锁的线程就可以进入到临界区了。
互斥锁：
| 互斥锁类型 | pthread_mutex_t mutex; | ||
| 初始化函数 |
int pthread_mutex_init ( pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr ); |
||
| 销毁函数 |
int pthread_mutex_destroy(pthread_mutex_t *mutex); |
||
| 加锁函数 | int pthread_mutex_lock(pthread_mutex_t *mutex); | ||
| 尝试加锁函数 |
int pthread_mutex_trylock(pthread_mutex_t *mutex); |
||
| 解锁函数 | int pthread_mutex_unlock(pthread_mutex_t *mutex); | ||
例子1：两个线程并发计数
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <pthread.h>
#define MAX 100
// 全局变量
int number;
// 创建一把互斥锁
// 全局变量, 多个线程共享
pthread_mutex_t mutex;
// 线程处理函数
void* funcA_num(void* arg)
{
for(int i=0; i<MAX; ++i)
{
// 如果线程A加锁成功, 不阻塞
// 如果B加锁成功, 线程A阻塞
pthread_mutex_lock(&mutex);
int cur = number;
cur++;
usleep(10);
number = cur;
pthread_mutex_unlock(&mutex);
printf("Thread A, id = %lu, number = %d\n", pthread_self(), number);
}
return NULL;
}
void* funcB_num(void* arg)
{
for(int i=0; i<MAX; ++i)
{
// a加锁成功, b线程访问这把锁的时候是锁定的
// 线程B先阻塞, a线程解锁之后阻塞解除
// 线程B加锁成功了
pthread_mutex_lock(&mutex);
int cur = number;
cur++;
number = cur;
pthread_mutex_unlock(&mutex);
printf("Thread B, id = %lu, number = %d\n", pthread_self(), number);
usleep(5);
}
return NULL;
}
int main(int argc, const char* argv[])
{
pthread_t p1, p2;
// 初始化互斥锁
pthread_mutex_init(&mutex, NULL);
// 创建两个子线程
pthread_create(&p1, NULL, funcA_num, NULL);
pthread_create(&p2, NULL, funcB_num, NULL);
// 阻塞，资源回收
pthread_join(p1, NULL);
pthread_join(p2, NULL);
// 销毁互斥锁
// 线程销毁之后, 再去释放互斥锁
pthread_mutex_destroy(&mutex);
return 0;
}
例子2：两个线程打印 hello world
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
void *function(void *arg);
pthread_mutex_t mutex;
int counter = 0;
int main(int argc, char *argv[])
{
int rc1,rc2;
char *str1="hello";
char *str2="world";
pthread_t thread1,thread2;
pthread_mutex_init(&mutex,NULL);
if((rc1 = pthread_create(&thread1,NULL,function,str1)))
{
fprintf(stdout,"thread 1 create failed: %d\n",rc1);
}
if(rc2=pthread_create(&thread2,NULL,function,str2))
{
fprintf(stdout,"thread 2 create failed: %d\n",rc2);
}
pthread_join(thread1,NULL);
pthread_join(thread2,NULL);
return 0;
}
void *function(void *arg)
{
char *m;
m = (char *)arg;
pthread_mutex_lock(&mutex);
while(*m != '\0')
{
printf("%c",*m);
fflush(stdout);
m++;
sleep(1);
}
printf("\n");
pthread_mutex_unlock(&mutex);
}
读写锁
| 读写锁类型 | pthread_rwlock_t rwlock; | ||
| 初始化函数 |
int pthread_rwlock_init (pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr); |
||
| 销毁函数 |
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock); |
||
| 加读锁 |
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); |
||
例子1：线程A和B依次读写数据data
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
pthread_rwlock_t rwlock;
int data=1;
void *readerA(){
while(1)
{
pthread_rwlock_rdlock(&rwlock);
printf("A读者读出:%d\n",data);
pthread_rwlock_unlock(&rwlock);
usleep(1);
}
}
void *writerB(){
while(1)
{
pthread_rwlock_wrlock(&rwlock);
data++;
printf("B作者写入:%d\n",data);
pthread_rwlock_unlock(&rwlock);
usleep(1);
}
}
int main()
{
pthread_t t1;
pthread_t t2;
pthread_rwlock_init(&rwlock,NULL);
pthread_create(&t1,NULL,readerA,NULL);
pthread_create(&t2,NULL,writerB,NULL);
pthread_join(t1,NULL);
pthread_join(t2,NULL);
pthread_rwlock_destroy(&rwlock);
return 0;
}
例子2：8个线程操作同一个全局变量，3个线程不定时写同一全局资源，5个线程不定时读同一全局资源。
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>
// 全局变量
int number = 0;
// 定义读写锁
pthread_rwlock_t rwlock;
// 写的线程的处理函数
void* writeNum(void* arg)
{
while(1)
{
pthread_rwlock_wrlock(&rwlock);
int cur = number;
cur ++;
number = cur;
printf("++写操作完毕, number : %d, tid = %ld\n", number, pthread_self());
pthread_rwlock_unlock(&rwlock);
// 添加sleep目的是要看到多个线程交替工作
usleep(rand() % 100);
}
return NULL;
}
// 读线程的处理函数
// 多个线程可以如果处理动作相同, 可以使用相同的处理函数
// 每个线程中的栈资源是独享
void* readNum(void* arg)
{
while(1)
{
pthread_rwlock_rdlock(&rwlock);
printf("--全局变量number = %d, tid = %ld\n", number, pthread_self());
pthread_rwlock_unlock(&rwlock);
usleep(rand() % 100);
}
return NULL;
}
int main()
{
// 初始化读写锁
pthread_rwlock_init(&rwlock, NULL);
// 3个写线程, 5个读的线程
pthread_t wtid[3];
pthread_t rtid[5];
for(int i=0; i<3; ++i)
{
pthread_create(&wtid[i], NULL, writeNum, NULL);
}
for(int i=0; i<5; ++i)
{
pthread_create(&rtid[i], NULL, readNum, NULL);
}
// 释放资源
for(int i=0; i<3; ++i)
{
pthread_join(wtid[i], NULL);
}
for(int i=0; i<5; ++i)
{
pthread_join(rtid[i], NULL);
}
// 销毁读写锁
pthread_rwlock_destroy(&rwlock);
return 0;
}
条件变量：
| 条件变量 | pthread_cond_t cond; | ||
| 初始化函数 |
int pthread_cond_init (pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr); |
||
| 销毁函数 |
int pthread_cond_destroy(pthread_cond_t *cond); |
||
| 线程阻塞 |
int pthread_cond_wait (pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex); |
||
| 唤醒函数 | int pthread_cond_signal(pthread_cond_t *cond); | ||
| 全部唤醒 | int pthread_cond_broadcast(pthread_cond_t *cond); | ||
例子1：生产者和消费者模型
#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;
}
信号量
| 信号量 | #include <semaphore.h> sem_t sem; |
||
| 初始化 |
int sem_init(sem_t *sem, int pshared, unsigned int value); |
||
| 销毁 | int sem_destroy(sem_t *sem); | ||
| 消耗资源 | int sem_wait(sem_t *sem); | ||
| 尝试消耗资源 | int sem_trywait(sem_t *sem); | ||
| 生产资源 | int sem_post(sem_t *sem); | ||
| 查看资源数 | int sem_getvalue(sem_t *sem, int *sval); | ||
例子：生产者消费者模型
#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);
// 加锁, 这句代码放到 sem_wait()上边, 有可能会造成死锁
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);
// 通知消费者消费
sem_post(&csem);
// 生产慢一点
sleep(rand() % 3);
}
return NULL;
}
// 消费者的回调函数
void* consumer(void* arg)
{
while(1)
{
sem_wait(&csem);
pthread_mutex_lock(&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);
// 通知生产者生成, 给生产者加信号灯
sem_post(&psem);
sleep(rand() % 3);
}
return NULL;
}
int main()
{
// 初始化信号量
sem_init(&psem, 0, 5); // 生成者线程一共有5个信号灯
sem_init(&csem, 0, 0); // 消费者线程一共有0个信号灯
// 初始化互斥锁
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);
}
sem_destroy(&psem);
sem_destroy(&csem);
pthread_mutex_destroy(&mutex);
return 0;
}1、有了进程为什么还要线程？ - Big_Foot - 博客园 (cnblogs.com)
