线程的同步互斥中的两个概念：临界资源、临界区：
- 临界资源：当多个任务同时访问一个资源的时候，我们将该资源称之为临界资源。
- 临界区：访问临界资源的代码，称之为临界区
- 线程之间，如果要进行通信，需要引入同步互斥机制，避免产生竞态。保证任何一个时刻都只有一个线程处理临界资源。
线程互斥和同步的区别？
互斥：
- 只能保证临界区完整，但是无法保证访问者的访问顺序。
- 互斥机制只可以保证临界区的完整性，唯一性，排他性。例如：互斥锁
同步：
- 在互斥机制的基础上，可以保证访问者的访问顺序。例如：条件变量。
同步互斥机制：
- 互斥锁
- 条件变量
- 信号量
一、互斥锁
1) 工作原理
1. 对于要访问临界资源的线程，在访问前，都先执行申请上锁操作
- 若上锁成功，则进入临界区执行临界区代码，直到退出临界区，解开互斥锁；
- 若上锁失败，则说明该互斥锁被别的线程占用，则线程进入休眠等待阶段，等待互斥锁被打开。
2. 互斥锁只能保证临界区完整，但是不能限制访问者的访问顺序。
2)【创建】pthread_mutex_init
功能：创建一个互斥锁;
原型：
#include <pthrea pthread_mutex_t fastmutex = PTHREAD_MUTEX_INITIALIZER; int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr);参数：
pthread_mutex_t *mutex：存储申请后的互斥锁;
const pthread_mutexattr_t *mutexattr：互斥锁属性，设置互斥锁适用于进程间还是线程间的同步互斥锁。 填NULL，默认属性，用于线程
返回值：
永远成功，返回0；
3)【上锁】pthread_mutex_lock
功能：对互斥锁进行上锁，若有其他线程占用互斥锁，该函数会阻塞；
原型：
#include <pthread.h> int pthread_mutex_lock(pthread_mutex_t *mutex);参数：
pthread_mutex_t *mutex;
返回值：
成功，返回0;
失败，返回非0，没有说更新errno，所以不要用perror打印错误。
4)【解锁】pthread_mutex_unlock
功能：解开互斥锁;
原型：
#include <pthread.h> int pthread_mutex_unlock(pthread_mutex_t *mutex);参数：
pthread_mutex_t *mutex;
返回值：
成功，返回0;
失败，返回非0，没有说更新errno，所以不要用perror打印错误。
5)【销毁】pthread_mutex_destroy
功能：销毁互斥锁;
原型：
#include <pthread.h> int pthread_mutex_destroy(pthread_mutex_t *mutex);参数：
pthread_mutex_t *mutex;
返回值：
成功，返回0;
失败，返回非0，没有说更新errno，所以不要用perror打印错误。
6) 死锁
拥有锁资源的任务没有释放锁。
- 持有互斥锁的线程异常退出，没有释放锁资源。
- 同一线程对一把互斥锁重复上锁。
- 互斥锁交叉嵌套。
7）作业：创建两个线程：其中一个线程拷贝前半部分，另一个线程拷贝后半部分
创建两个线程：其中一个线程拷贝前半部分，另一个线程拷贝后半部分。
只允许开一份资源，且用互斥锁方式实现。
提示：找临界区---》找临界资源。
允许线程1线程2来回拷贝，但不影响拷贝进度
结构体的方式：
#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
#include <head.h>
#include <pthread.h>
//定义一个结构体，传入到线程中
struct Msg
{
int fd_r;
int fd_w;
off_t size;
};
//定义互斥锁
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
//拷贝前半部分
void* callBack1(void* arg) //void* arg = &fileinfo
{
int fd_r = ((struct Msg*)arg)->fd_r;
int fd_w = ((struct Msg*)arg)->fd_w;
off_t size = ((struct Msg*)arg)->size;
//修改文件偏移量到文件开头位置
off_t offset = 0;
char c = 0;
for(int i = 0; i<size/2; i++)
{
/*********临界区****************/
pthread_mutex_lock(&mutex); //上锁
lseek(fd_r, offset, SEEK_SET);
lseek(fd_w, offset, SEEK_SET);
read(fd_r, &c, 1);
write(fd_w, &c, 1);
offset = lseek(fd_r, 0, SEEK_CUR);
pthread_mutex_unlock(&mutex); //解锁
/*********临界区****************/
}
printf("前半部分拷贝完毕\n");
pthread_exit(NULL);
}
//拷贝后半部分
void* callBack2(void* arg) //void* arg = &fileinfo
{
int fd_r = ((struct Msg*)arg)->fd_r;
int fd_w = ((struct Msg*)arg)->fd_w;
off_t size = ((struct Msg*)arg)->size;
//修改文件偏移量到sizee/2位置
off_t offset = size/2;
char c = 0;
for(int i = size/2; i<size; i++)
{
/*********临界区****************/
pthread_mutex_lock(&mutex); //上锁
lseek(fd_r, offset, SEEK_SET);
lseek(fd_w, offset, SEEK_SET);
read(fd_r, &c, 1);
write(fd_w, &c, 1);
offset = lseek(fd_r, 0, SEEK_CUR);
pthread_mutex_unlock(&mutex); //解锁
/*********临界区****************/
}
printf("后半部分拷贝完毕\n");
pthread_exit(NULL);
}
int main(int argc, const char *argv[])
{
//以读的方式打开源文件
int fd_r = open("./1.png", O_RDONLY);
if(fd_r < 0)
{
ERR_MSG("open");
return -1;
}
//以写的方式打开目标文件
int fd_w = open("./copy.png", O_WRONLY|O_CREAT|O_TRUNC, 0664);
if(fd_w < 0)
{
ERR_MSG("open");
return -1;
}
off_t size = lseek(fd_r, 0, SEEK_END);
struct Msg fileinfo;
fileinfo.fd_r = fd_r;
fileinfo.fd_w = fd_w;
fileinfo.size = size;
//创建一个线程
pthread_t tid1, tid2;
if(pthread_create(&tid1, NULL, callBack1, &fileinfo) != 0)
{
fprintf(stderr, "pthread_create failed __%d__\n", __LINE__);
return -1;
}
if(pthread_create(&tid2, NULL, callBack2, &fileinfo) != 0)
{
fprintf(stderr, "pthread_create failed __%d__\n", __LINE__);
return -1;
}
//阻塞等待分支线程退出
pthread_join(tid2, NULL);
pthread_join(tid1, NULL);
//销毁互斥锁
pthread_mutex_destroy(&mutex);
//关闭文件
close(fd_r);
close(fd_w);
return 0;
}
运行结果：
ubuntu@ubuntu:04_pthread$ gcc 1.c -pthread
ubuntu@ubuntu:04_pthread$ ./a.out
前半部分拷贝完毕
后半部分拷贝完毕
ubuntu@ubuntu:04_pthread$ ls -l
总用量 536
-rw-rw-r-- 1 ubuntu ubuntu 3098 八月 4 18:42 1.c
-rw-rw-r-- 1 ubuntu ubuntu 229010 一月 2 2023 1.png
-rw-rw-r-- 1 ubuntu ubuntu 229010 八月 4 18:43 copy.png
ubuntu@ubuntu:04_pthread$ diff 1.png copy.png
ubuntu@ubuntu:04_pthread$
二、信号量（信号灯）
1) 工作原理
1. 对于访问共享资源的线程，都去执行申请信号量的操作。
- 当信号量的值大于0，则申请成功，信号量的值-1；
- 当信号量的值等于0，则申请信号量操作会阻塞，线程进入休眠等待阶段。
2. 互斥锁又称之为二值信号量：信号量的值要么为0，要么为1，最多只允许一个线程申请信号量成功。
3. 信号量允许多个线程同时进入临界区，主要看初始值为多少，若初始值为2，则允许两个线程同时申请信号量成功，
4. PV操作：实现线程、进程同步互斥的有效方式
- P操作：申请信号量，-1操作
- V操作：释放信号量，+1操作
2)【创建】sem_init
功能：创建并初始化信号量；
原型：
#include <semaphore.h> int sem_init(sem_t *sem, int pshared, unsigned int value);参数：
sem_t *sem：存储申请后的信号量; int pshared：共享标识 0：信号量用于同一个进程下的线程的同步互斥； 非0：用于进程间的同步互斥机制; unsigned int value：信号量的初始值;返回值：
成功，返回0；
失败，返回-1，更新errno;
3)【P操作】sem_wait
功能：申请信号量，若申请成功，信号量的值-1；
- 当信号量的值>0，则申请信号量成功，信号量的值-1；
- 当信号量的值=0，则申请信号量操作会阻塞，线程进入休眠等待信号量的值大于0，解除阻塞。
原型：
#include <semaphore.h> int sem_wait(sem_t *sem);参数：
sem_t *sem：指定要操作哪个信号灯;
返回值：
成功，返回0；
失败，返回-1，更新errno;
4)【V操作】sem_post
功能：释放信号灯的值;
原型：
#include <semaphore.h> int sem_post(sem_t *sem);参数：
sem_t *sem：指定要操作哪个信号灯;
返回值：
成功，返回0;
失败，返回-1，更新errno
5)【销毁】sem_destroy
功能：销毁互斥锁;
原型：
#include <semaphore.h> int sem_destroy(sem_t *sem);参数：
sem_t *sem：指定要操作哪个信号灯；
6) 示例
#include <stdio.h>
#include <pthread.h>
#include <string.h>
#include <semaphore.h>
//临界资源
char buf[] = "1234567";
//信号量
sem_t sem;
void* callBack1(void* arg)
{
while(1)
{
/**********临界区***********/
//P操作
if(sem_wait(&sem) < 0)
{
perror("sem_wait");
break;
}
printf("%s\n", buf);
//V操作
if(sem_post(&sem) < 0)
{
perror("sem_post");
break;
}
/**********临界区***********/
}
pthread_exit(NULL);
}
void* callBack2(void* arg)
{
char tmp = 0;
while(1)
{
/**********临界区***********/
//P操作
if(sem_wait(&sem) < 0)
{
perror("sem_wait");
break;
}
for(int i=0; i<strlen(buf)/2; i++)
{
tmp = buf[i];
buf[i] = buf[strlen(buf)-1-i];
buf[strlen(buf)-1-i] = tmp;
}
//V操作
if(sem_post(&sem) < 0)
{
perror("sem_post");
break;
}
/**********临界区***********/
}
pthread_exit(NULL);
}
int main(int argc, const char *argv[])
{
//申请信号量
if(sem_init(&sem, 0, 1) < 0)
{
perror("sem_init");
return -1;
}
pthread_t tid1, tid2;
if(pthread_create(&tid1, NULL, callBack1, NULL) != 0)
{
fprintf(stderr, "pthread_create failed __%d__\n", __LINE__);
return -1;
}
pthread_detach(tid1); //分离线程1
if(pthread_create(&tid2, NULL, callBack2, NULL) != 0)
{
fprintf(stderr, "pthread_create failed __%d__\n", __LINE__);
return -1;
}
pthread_join(tid2, NULL); //阻塞等待线程2退出
//销毁信号量
sem_destroy(&sem);
return 0;
}
7）作业1：要求顺序执行 线程1、线程2【不使用flag】
在第一题的基础上加上一个需求：要求打印，倒置线程，顺序执行。出现的现象为先打印1234567，后打印7654321
不使用flag
8）作业2：
创建两个线程，其中一个线程读取文件中的数据，另外一个线程将读取到的内容打印到终端上，类似实现cat一个文件。
cat数据完毕后，要结束两个线程。
提示：先读数据，读到数据后将数据打印到终端上。
三、条件变量
1) 工作原理
- 将不访问共享资源的线程直接休眠，并设置一个唤醒条件，该唤醒条件就是条件变量。
- 当线程要访问临界资源的时候，其他线程通过指定的条件变量就可以唤醒该线程。
- 条件变量不仅可以实现临界区的完整性，还可以实现访问者的有序执行。
2)【创建】pthread_cond_init
功能：创建并初始化一个条件变量（唤醒条件）;
原型：
#include <pthread.h> pthread_cond_t cond = PTHREAD_COND_INITIALIZER; int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr);参数：
pthread_cond_t *cond：指定存储创建并初始化后的条件变量; pthread_condattr_t *cond_attr：条件变量属性，设置条件变量适用于进程间还是线程间的同步互斥。 填NULL，默认属性，用于线程返回值：
成功，返回0；
失败，返回非0，没有说更新errno，所以不要用perror打印错误。
3)【休眠】pthread_cond_wait
功能：创建一个互斥锁;
原型：
#include <pthread.h> int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);参数：
pthread_cond_t *cond：指定条件变量; 我们一般称 该线程睡在该条件变量上; pthread_mutex_t *mutex：指定要解开的互斥锁；返回值：
成功，返回0；
失败，返回非0，没有说更新errno，所以不要用perror打印错误。
函数步骤：
- 解开互斥锁，同时让当前线程进入休眠阶段等待被唤醒。（原子操作：原子从操作是指不会被调度机制打断的操作）
- 等待被指定条件变量唤醒
- 当其他线程pthread_cond_signal的时候，线程会从cond_wait队列移动到mutex_lock队列中，且signal计数器+1，线程尝试上锁
- 若上锁成功，则线程完全被唤醒，此时线程会从当前位置继续往后执行，且signal计数器-1;
- 若上锁失败，则线程会重新回到cond_wait队列上继续休眠，等待下一次唤醒。
ps：如果上述不能理解，则简化版：pthread_cond_signal肯定会随机唤醒一个睡在cond上的线程。
4)【唤醒】pthread_cond_signal
功能：通过指定条件变量，唤醒睡在该条件变量上的某个线程;
原型：
#include <pthread.h> int pthread_cond_signal(pthread_cond_t *cond);参数：
pthread_cond_t *cond：唤醒睡在哪个条件变量上的线程;
返回值：
成功，返回0;
失败，返回非0，没有说更新errno，所以不要用perror打印错误
5)【销毁】pthread_cond_destroy
功能：销毁条件变量；
原型：
#include <pthread.h> int pthread_cond_destroy(pthread_cond_t *cond);参数：
pthread_cond_t *cond：销毁哪个条件变量上的线程;
6）示例
#include <stdio.h>
#include <pthread.h>
#include <string.h>
#include <unistd.h>
char buf[] = "1234567";
//互斥锁 //方式2
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
//条件变量创建 方式2
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int flag = 0; //限制访问时机
void* callBack1(void* arg)
{
while(1)
{
/******临界区******/
//上锁
pthread_mutex_lock(&mutex);
if(flag != 0)
{
//让线程进入休眠等待阶段，同时解开互斥锁
//设置一个唤醒条件
pthread_cond_wait(&cond, &mutex);
//当被唤醒的时候，会立即尝试上锁，
//上锁成功，则唤醒成功，则从当前位置继续往后执行
//上锁失败，则重新回到cond上继续休眠，等待下一次唤醒
}
printf("%s\n", buf);
flag = 1;
//唤醒睡在cond上的线程
pthread_cond_signal(&cond);
//解锁
pthread_mutex_unlock(&mutex);
/******临界区******/
}
pthread_exit(NULL);
}
void* callBack2(void* arg)
{
char* start , *end;
char tmp;
while(1)
{
/******临界区******/
//上锁
pthread_mutex_lock(&mutex);
if(flag != 1)
{
//让线程进入休眠等待阶段，同时解开互斥锁
//设置一个唤醒条件
pthread_cond_wait(&cond, &mutex);
//当被唤醒的时候，会立即尝试上锁，
//上锁成功，则唤醒成功，则从当前位置继续往后执行
//上锁失败，则重新回到cond上继续休眠，等待下一次唤醒
}
start = buf;
end = buf+strlen(buf)-1;
while(start < end)
{
tmp = *start;
*start = *end;
*end = tmp;
start++;
end--;
}
flag = 0;
//唤醒睡在cond上的线程
pthread_cond_signal(&cond);
//解锁
pthread_mutex_unlock(&mutex);
/******临界区******/
}
pthread_exit(NULL);
}
int main(int argc, const char *argv[])
{
/*
//创建一个条件变量 方式1
if(pthread_cond_init(&cond, NULL) != 0)
{
fprintf(stderr, "pthread_cond_init failed __%d__\n", __LINE__);
return -1;
}
*/
pthread_t tid1, tid2;
if(pthread_create(&tid1, NULL, callBack1, NULL) != 0)
{
fprintf(stderr, "pthread_create failed __%d__\n", __LINE__);
return -1;
}
pthread_detach(tid1); //分离线程1
if(pthread_create(&tid2, NULL, callBack2, NULL) != 0)
{
fprintf(stderr, "pthread_create failed __%d__\n", __LINE__);
return -1;
}
pthread_join(tid2, NULL); //阻塞等待线程2退出
//销毁互斥锁
pthread_mutex_destroy(&mutex);
pthread_cond_destroy(&cond);
return 0;
}7) 练习：创建三个线程 id号为ABC，要求三个线程循环打印自己的ID号，运行顺序为 ABCABC......
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
//创建互斥锁
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
//条件变量创建
pthread_cond_t cond1 =PTHREAD_COND_INITIALIZER;
pthread_cond_t cond2 =PTHREAD_COND_INITIALIZER;
pthread_cond_t cond3 =PTHREAD_COND_INITIALIZER;
//限制访问机制
int flag=1;
void* callback1(void* arg)
{
while(1)
{
/*************临界区**************/
//上锁
pthread_mutex_lock(&mutex);
if(flag != 1)
{
//休眠 解锁
pthread_cond_wait(&cond1,&mutex);
}
printf("A");
flag=2;
//唤醒
pthread_cond_signal(&cond2);
//解锁
pthread_mutex_unlock(&mutex);
/*************临界区**************/
}
pthread_exit(NULL);
}
void* callback2(void* arg)
{
while(1)
{
/*************临界区**************/
//上锁
pthread_mutex_lock(&mutex);
if(flag != 2)
{
//休眠 解锁
pthread_cond_wait(&cond2,&mutex);
}
printf("B");
flag=3;
//唤醒
pthread_cond_signal(&cond3);
//解锁
pthread_mutex_unlock(&mutex);
/*************临界区**************/
}
pthread_exit(NULL);
}
void* callback3(void* arg)
{
while(1)
{
/*************临界区**************/
//上锁
pthread_mutex_lock(&mutex);
if(flag != 3)
{
//休眠 解锁
pthread_cond_wait(&cond3,&mutex);
}
printf("C\n");
flag=1;
//唤醒
pthread_cond_signal(&cond1);
//解锁
pthread_mutex_unlock(&mutex);
/*************临界区**************/
}
pthread_exit(NULL);
}
int main(int argc, const char *argv[])
{
//练习1.创建三个线程id号为ABC,要求三个线程循环打印自己的ID号， 运行顺序为ABCAB.....
pthread_t A,B,C;
if(pthread_create(&A,NULL,callback1,NULL)!=0)
{
fprintf(stderr,"pthread_create faild __%d__\n",__LINE__);
return -1;
}
if(pthread_create(&B,NULL,callback2,NULL)!=0)
{
fprintf(stderr,"pthread_create faild __%d__\n",__LINE__);
return -1;
}
if(pthread_create(&C,NULL,callback3,NULL)!=0)
{
fprintf(stderr,"pthread_create faild __%d__\n",__LINE__);
return -1;
}
pthread_join(A,NULL);
pthread_join(B,NULL);
pthread_join(C,NULL);
//销毁互斥锁
pthread_mutex_destroy(&mutex);
//销毁条件变量
pthread_cond_destroy(&cond1);
pthread_cond_destroy(&cond2);
pthread_cond_destroy(&cond3);
return 0;
}
运行结果：死循环输出ABC\n
ubuntu@ubuntu:04_pthread$ gcc t3.3pthread.c -pthread
ubuntu@ubuntu:04_pthread$ ./a.out
ABC
ABC
ABC
ABC
ABC
