IO进程（线程篇）

知识点链接

https://www.yuque.com/aihenaobaijin/camuoq/lscmvf6z1arklau4?singleDoc# 《IO进程》

建议先学习知识点，再进行下面的练习

线程

概念

线程是一个轻量级的进程，为了提高系统的性能引入线程

线程和进程是参与统一的调度

在同一个进程中可以创建的多个线程，共享进程资源

线程资源

共享的资源：可执行的指令、静态数据、进程中打开的文件描述符、信号处理函数、当前工作目录、用户ID、用户组ID

私有的资源：线程ID (TID)、PC(程序计数器)和相关寄存器、堆栈(局部变量, 返回地址)、错误号 (errno)、信号掩码和优先级、执行状态和属性

 练习：循环输入输出，quit结束

通过线程实现数据的交互，主线程循环从终端输入，线程函数将数据循环输出，当输入quit结束程序。

1）全局变量进行通信

2）加上标志位(flag)，实现主线程输入一次，线程函数打印一次， int flag = 0;

#include <stdio.h>
#include <pthread.h>
#include <string.h>
char s[32];
int flag = 0; //为了进行线程间通讯，保证主线程先输入然后从线程再输出void *handler_thread(void *arg)
{while (1){if (flag == 1) //主线程输入完将flag置1从线程再输出{if (strcmp(s, "quit") == 0)break;printf("%s\n", s);flag--;}}return NULL;
}int main(int argc, char const *argv[])
{pthread_t tid;if (pthread_create(&tid, NULL, handler_thread, NULL) > 0){perror("err");return -1;}while (1){//scanf前也可以不加if判断，利用阻塞时间让从线程输出// if (flag == 0)  //从线程输出完将flag置0主线程再输入// {scanf("%s", s);flag++;if (strcmp(s, "quit") == 0)break;// }}
}

同步

概念

同步(synchronization)指的是多个任务(线程)按照约定的顺序相互配合完成一件事情(异步：异步则反之，并非一定需要一件事做完再做另一件事）

同步机制

通过信号量实现线程间同步。

信号量：通过信号量实现同步操作；由信号量来决定线程是继续运行还是阻塞等待。

信号量代表某一类资源，其值表示系统中该资源的数量:

信号量的值>0, 表示有资源可以用, 可以申请到资源。

信号量的值<=0, 表示没有资源可以用, 无法申请到资源, 阻塞。

信号量还是一个受保护的变量，只能通过三种操作来访问：初始化、Ｐ操作(申请资源)、Ｖ操作(释放资源)

sem_init:信号量初始化

sem_wait:申请资源，P操作，如果没有资源可以用会阻塞等待，直到有资源可用结束阻塞资源-1。

sem_post:释放资源，V操作，非阻塞，资源+1。

练习：用信号量实现循环输入输出quit结束

#include <stdio.h>
#include <pthread.h>
#include <string.h>
#include <semaphore.h>char s[32];
sem_t sem1; //信号量对象
sem_t sem2;void *handler_thread(void *arg)
{while (1){//申请资源 sem1sem_wait(&sem1);if (strcmp(s, "quit") == 0)break;printf("%s\n", s);//释放资源sem2sem_post(&sem2);}return NULL;
}int main(int argc, char const *argv[])
{pthread_t tid;//初始化信号量if (sem_init(&sem1, 0, 0) != 0){perror("sem_init err");return -1;}if (sem_init(&sem2, 0, 1) != 0){perror("sem_init err");return -1;}if (pthread_create(&tid, NULL, handler_thread, NULL) != 0){perror("err");return -1;}while (1){//申请资源sem2sem_wait(&sem2);scanf("%s", s);//释放资源sem1sem_post(&sem1);if (strcmp(s, "quit") == 0)break;}
}

互斥

概念

互斥：多个线程在访问临界资源时，同一时间只能一个线程访问

临界资源：一次仅允许一个线程所使用的资源

临界区：指的是一个访问共享资源的程序片段

互斥锁（mutex）：通过互斥锁可以实现互斥机制，主要用来保护临界资源，每个临界资源都由一个互斥锁来保护，线程必须先获得互斥锁才能访问临界资源，访问完资源后释放该锁。如果无法获得锁，线程会阻塞直到获得锁为止。

pthread_mutex_init：初始化互斥锁

pthread_mutex_lock：申请互斥锁

pthread_mutex_unlock：释放互斥锁

pthread_mutex_destroy：销毁互斥锁

 练习：打印倒置数组功能

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>int a[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
pthread_mutex_t lock;void *handler_swap(void *arg)
{while (1){pthread_mutex_lock(&lock);  //上锁for (int i = 0; i < 5; i++){int t = a[i];a[i] = a[9 - i];a[9 - i] = t;}pthread_mutex_unlock(&lock); //解锁}return NULL;
}void *handler_print(void *arg)
{while (1){pthread_mutex_lock(&lock); //上锁for (int i = 0; i < 10; i++)printf("%d ", a[i]);printf("\n");pthread_mutex_unlock(&lock); //解锁sleep(1); //锁里面减少耗时大的操作}return NULL;
}int main(int argc, char const *argv[])
{pthread_t tid1, tid2;//初始化互斥锁if (pthread_mutex_init(&lock, NULL) != 0){perror("lock err");return -1;}if (pthread_create(&tid1, NULL, handler_swap, NULL) != 0){perror("err");return -1;}if (pthread_create(&tid2, NULL, handler_print, NULL) != 0){perror("err");return -1;}pthread_join(tid1, NULL); //为了让整个进程不要结束pthread_join(tid2, NULL);return 0;
}

死锁

死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。

死锁产生的四个必要条件

1、互斥使用，即当资源被一个线程使用(占有)时，别的线程不能使用

2、 不可抢占，资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放。

3、 请求和保持，即当资源请求者在请求其他的资源的同时保持对原有资源的占有。

4、 循环等待，即存在一个等待队列：P1占有P2的资源，P2占有P3的资源，P3占有P1的资源。这样就形成了一个等待环路。

注意：当上述四个条件都成立的时候，便形成死锁。当然，死锁的情况下如果打破上述任何一个条件，便可让死锁消失。

 条件变量

条件变量(cond)用于在线程之间传递信号，以便某些线程可以等待某些条件发生。当某些条件发生时，条件变量会发出信号，使等待该条件的线程可以恢复执行。

一般和互斥锁搭配使用，实现同步机制:

pthread_cond_init(&cond,NULL); //初始化条件变量

使用前需要上锁:

pthread_mutex_lock(&lock); //上锁

//判断条件

pthread_cond_wait(&cond, &lock); //阻塞等待条件产生，没有条件产生时阻塞，同时解锁；当条件产生时结束阻塞，再次上锁

//执行任务

pthread_mutex_unlock(&lock); //解锁

pthread_cond_signal(&cond); //产生条件，不阻塞

pthread_cond_destroy(&cond); //销毁条件变量

注意： 必须保证让pthread_cond_wait先执行，pthread_cond_signal再产生条件

练习：打印和转置数组实现同步

#include <stdio.h>
#include <string.h>
#include <pthread.h>
#include <semaphore.h>
#include <unistd.h>int arr[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
pthread_mutex_t lock;
pthread_cond_t cond;//初始化条件变量
void *headler_swap(void *arg)
{while (1){pthread_mutex_lock(&lock);//上锁：申请锁//阻塞等待条件产生，没有条件产生时解锁并阻塞//当条件产生时结束阻塞，再次上锁pthread_cond_wait(&cond,&lock);for (int i = 0; i < 5; i++){int t = arr[i];arr[i] = arr[9 - i];arr[9 - i] = t;}pthread_mutex_unlock(&lock);//解锁：释放锁}return NULL;
}
void *headler_print(void *arg)
{while (1){sleep(1);pthread_mutex_lock(&lock);//上锁：申请锁for (int i = 0; i < 10; i++){printf("%d ", arr[i]);}printf("\n");pthread_cond_signal(&cond);//产生条件pthread_mutex_unlock(&lock);//解锁：释放锁sleep(1);}return NULL;
}
int main(int argc, char const *argv[])
{pthread_t tid1, tid2;//初始化互斥锁if (pthread_mutex_init(&lock, NULL) != 0){perror("lock error");return -1;}if (pthread_create(&tid1, NULL, headler_swap, NULL) != 0){perror("pthread error");return -1;}if (pthread_create(&tid2, NULL, headler_printf, NULL) != 0){perror("pthread error");return -1;}pthread_join(tid1, NULL);//为了让整个进程不要结束pthread_join(tid2, NULL);return 0;
}