-
【操作系统】线程的使用
线程
为什么使用线程?
- 使用fork创建进程以执行新的任务，该方式的代价很高——子进程将父进程的所有资源都复制一遍。
- 多个进程之间不会直接共享内存。
进程是系统分配资源的基本单位，线程是进程的基本执行单元，一个进程的所有任务都在线程中执行，进程想要执行任务，必须得有线程，进程至少要有一条线程，程序启动会默认开启一条线程，这条线程被称为主线程或UI线程。
什么是线程？
- 线程是进程内部的一个控制序列。
- 类比:
- 创建一个进程，就类似于克隆一个家庭，新的"家庭"与原来的家庭完全相同，但是新"家庭"和原来的家庭完全独立。
- 进程包含一个或多个线程，就像一个家庭中包含一个或多个家庭成员。
- 家庭内的各个成员同时做各自的事情，而对于家庭外部的人来说，就是这个家庭同时在做多件事情。
- 家庭内的每个成员，就是一个线程。每个家庭成员都有自己的个人资源，即线程有自己的局部变量。
- 所有的家庭成员都能共享这个家庭的资源，即同一个进程内的各个线程，都能共享当前这个进程中的全局变量，除了线程自己的局部变量外，其它资源都共享。
- 注意:
- 在单核处理器上，同一个时刻，只能运行一个线程。但是对于用户而言，感觉像是执行了多个线程一样，是因为各个线程在单核CPU上不断进行切换。
线程的优缺点
- 优点:创建线程比创建进程
开销要小。 - 缺点:
- 多线程编程要多加小心，很容易发生错误。
- 多线程调试很困难。
- 补充:
- 把一个任务划分为两部分，如果在单核处理器上运行，速度不一定更快。除非能确定这个任务运行在多核处理器上，即两部分可以同时执行。
线程的应用场合
- 需要让用户感觉同时在做多件事情时。
- 比如:处理文档的进程，一个线程处理用户编辑，一个线程同时统计用户字数。
- 当一个应用程序，需要同时处理输入、计算、输出时。
- 可开3个线程，分别处理输入、计算、输出。
- 综上所述，即
高并发编程。
线程的使用
线程的创建
- pthread_create
- 功能:创建一个新线程。
- 同时指定该线程的属性、执行函数、执行函数的参数。
- 函数原型:
int pthread_create ( pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void*), void *arg );- 1
- 2
- 3
- 4
- 5
- 6
- 参数:
- thread:指向新的线程标识符。
- attr:用来设置新线程的属性。
- 一般取默认属性，即该参数取NULL。
- start_routine:该线程的处理函数。
- 该函数的返回类型和参数类型都是void*。
- arg:线程处理函数start_routine的参数。
- 返回值:
- 成功:返回0。
- 失败:返回错误代码。(错误代码，这里略过，其它函数也是如此。)
- 注意:
- 使用fork创建进程后，进程马上就启动，
执行的是fork后面的代码。 - 使用pthread_create创建线程后，新线程马上就启动，
执行对应的线程处理函数。
- 使用fork创建进程后，进程马上就启动，
线程的终止
- pthread_exit
- 功能:在线程函数内部调用该函数，对本线程进行终止，返回值通过参数retval指定。
- 函数原型:void pthread_exit (void *retval)
- 参数：
- retval：它指向的数据为线程退出时的返回值，如果不需要接收该线程的返回值，设置NULL即可。
- 参考补充:
等待指定线程结束
- pthread_join
- 功能:等待指定线程结束，并获取该线程的返回值。
- 函数原型:int pthread_join (pthread_t th,void ** thread_return);
- 参数:
- th:线程标识符，指定要的等待的线程。
- thread_return:指向(接收)当前线程的返回值。参数类型为void**。
- 返回值
- 成功:返回0。
- 失败:返回错误号。
使用线程程序的编译
- 定义宏:_REENTRANT——可重入
- 即:gcc -D_REENTRANT
- 功能:告诉编译器，编译时需要可重用功能。
- 即，在编译时，编译部分函数的可重入版本。将共享的资源给本线程独享。
- 注意:
- 在单线程程序中，整个程序都是顺序执行的，一个函数在同一时刻只能被一个函数调用，但是在多线程中，由于并发性，一个函数可能同时被多个函数调用，此时这个函数就成了临界资源，很容易造成调用函数时，
处理结果的相互影响。 - 如果一个函数在多线程并发的环境中，每次被调用产生的结果是不确定的，我们就说这个函数是
不可重入的/线程不安全的。
- 在单线程程序中，整个程序都是顺序执行的，一个函数在同一时刻只能被一个函数调用，但是在多线程中，由于并发性，一个函数可能同时被多个函数调用，此时这个函数就成了临界资源，很容易造成调用函数时，
- 编译时，指定线程库。
- 即:gcc xxx -lpthread
- 功能:使用系统默认的NPTL线程库。
- 即，在默认路径中寻找库文件libpthread.so。默认路径为/usr/lib和usr/local/lib
- 功能:使用系统默认的NPTL线程库。
- 即:gcc xxx -lpthread
- 一般使用如下形式即可:
- gcc mythread.c -o mythread -D_REENTRANT -lpthread
示例:
#include#include #include int my_global; void* my_thread_handle(void* arg){ int val; val = *((int*)arg); printf("new thread begin,arg=%d\n",val); my_global += val; sleep(3); pthread_exit(&my_global); //下面一行不再执行 printf("new thread end\n"); } int main(void){ pthread_t mythread; int arg; int ret; void *thread_return; arg = 100; my_global = 1000; printf("my_global=%d\n", my_global); printf("ready create thread...\n"); ret = pthread_create(&mythread,0,my_thread_handle,&arg); if (ret != 0) { printf("create thread failed!\n"); exit(1); } printf("wait thread finished...\n"); ret = pthread_join(mythread,&thread_return); if (ret != 0) { printf("pthread_join failed!\n"); exit(1); } printf("wait thread end, return value is %d\n", *((int*)thread_return)); printf("my_global=%d\n", my_global); printf("create thread finished!\n"); return 0; } - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
线程的同步与互斥
- 线程的互斥:
- 指某一资源同一时间只允许一个访问者对其进行访问，具有唯一性和排它性。
- 但互斥无法限制访问者对资源的访问顺序，即访问是无序的。
- 线程的同步:
- 指在互斥的基础上(大多数情况)，通过其它机制实现访问者对资源的有序访问。
- 问题 :同一个进程内的各个线程，共享该进程的全局变量，如果多个线程同时对某个全局变量进行访问时，就可能导致竞态。
- 有关竞态:多线程对共享资源的访问。
- 解决办法:对临界区使用信号量、或互斥量。
- 信号量和互斥量的选择:对于同步和互斥，使用信号量和互斥量都可以实现。使用时选择更符合情况的:
- 如果要求
最多只允许一个线程进入临界区，则使用互斥量。 - 如果要求
多个线程之间的执行顺序满足某个约束，则使用信号量。
- 如果要求
信号量
什么是信号量？
- 此时所指的"信号量"是指用于同一个进程内多个线程之间的信号量。即
POSIX信号量，而不是System V信号量。(用于进程之间的信号量)。 - 用于线程的信号量原理与用于进程之间的信号量原理相同。都有P、V操作。
- 信号量的表示:sem_t类型。
信号量的初始化
- sem_init
- 功能:对信号量进行初始化。
- 函数原型:int sem_init (sem_t *sem， int pshared, unsigned int value);
- 参数:
- sem:指向要被初始化的信号量。
- pshared：
- 0表示该信号量是该进程内使用的"局部信号量",不再被其它进程共享。
- 非0表示该信号量可被其它进程共享，Linux不支持这种信号量。
- value:信号量的初值。>=0
- 返回值:
- 成功:返回0。
- 失败:返回错误码。
信号量的P操作
- sem_wait
- 功能:信号量的P操作。-1
- 函数原型:int sem_wait (sem_t *sem);
- 参数:
- sem:要操作的信号量。
- 返回值:
- 成功:返回0。
- 失败:返回错误码。
信号量的V操作
- sem_post
- 功能:信号量的V操作。+1
- 函数原型:int sem_post (sem_t *sem);
- 参数:
- sem:要操作的信号量。
- 返回值:
- 成功:返回0。
- 失败:返回错误码。
信号量的删除
- sem_destroy
- 功能:删除信号量。
- 函数原型:int sem_destroy (sem_t *sem);
- 参数:
- sem:要操作的信号量。
- 返回值:
- 成功: 返回0。
- 失败:返回错误码。
示例:
#include#include #include #include #include #define BUFF_SIZE 80 char buff[BUFF_SIZE]; sem_t sem; static void* str_thread_handle(void *arg) { while(1) { //P(sem) -1 if (sem_wait(&sem) != 0) { printf("sem_wait failed!\n"); exit(1); } printf("string is: %slen=%d\n", buff, strlen(buff)); if (strncmp(buff, "end", 3) == 0) { break; } } } int main(void) { int ret; pthread_t str_thread; void *thread_return; ret = sem_init(&sem, 0, 0); if (ret != 0) { printf("sem_init failed!\n"); exit(1); } ret = pthread_create(&str_thread, 0, str_thread_handle, 0); if (ret != 0) { printf("pthread_create failed!\n"); exit(1); } while (1) { fgets(buff, sizeof(buff), stdin); //V(sem) +1 if (sem_post(&sem) != 0) { printf("sem_post failed!\n"); exit(1); } if (strncmp(buff, "end", 3) == 0) { break; } } ret = pthread_join(str_thread, &thread_return); if (ret != 0) { printf("pthread_join failed!\n"); exit(1); } ret = sem_destroy(&sem); if (ret != 0) { printf("sem_destroy failed!\n"); exit(1); } return 0; } - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
互斥量
什么是互斥量?
效果等同于初始值为1的信号量。
互斥量的初始化
- pthread_mutex_init
- 功能:初始化互斥量。
- 函数原型:int pthread_mutex_init(pthread_mutex_t *mutex,pthread_mutexattr_t *attr);
- 参数:
- mutex:指向被初始化的互斥量。
- attr:互斥量的属性，一般取默认属性。
- 返回值:
- 成功:返回0。
- 失败:返回错误码。
互斥量的获取
- pthread_mutex_lock
- 功能:获取互斥量。
- 函数原型:int pthread_mutex_lock (pthread_mutex_t *mutex);
- 参数:
- mutex:指向要操作的互斥量。
- 返回值:
- 成功:返回0。
- 失败:返回错误码。
互斥量的删除
- pthread_mutex_destroy
- 功能:删除互斥量。
- 函数原型:int pthread_mutex_destroy (pthread_mutex_t *mutex);
- 参数:
- mutex:指向要操作的互斥量。
- 返回值:
- 成功:返回0。
- 失败:返回错误码。
示例:
#include#include #include #include #include #define BUFF_SIZE 80 int global_value = 1000; pthread_mutex_t lock; static void* str_thread_handle(void *arg) { int i = 0; for (i=0; i<10; i++) { pthread_mutex_lock(&lock); if (global_value > 0) { // work sleep(1); printf("soled ticket(%d) to ChildStation(%d)\n", global_value, i+1); } global_value--; pthread_mutex_unlock(&lock); sleep(1); } } int main(void) { int ret; pthread_t str_thread; void *thread_return; int i; ret = pthread_mutex_init(&lock, 0); if (ret != 0) { printf("pthread_mutex_init failed!\n"); exit(1); } ret = pthread_create(&str_thread, 0, str_thread_handle, 0); if (ret != 0) { printf("pthread_create failed!\n"); exit(1); } for (i=0; i<10; i++) { pthread_mutex_lock(&lock); if (global_value > 0) { // work sleep(1); printf("soled ticket(%d) to MainStation(%d)\n", global_value, i+1); } global_value--; pthread_mutex_unlock(&lock); sleep(1); } ret = pthread_join(str_thread, &thread_return); if (ret != 0) { printf("pthread_join failed!\n"); exit(1); } ret = pthread_mutex_destroy(&lock); if (ret != 0) { printf("pthread_mutex_destroy failed!\n"); exit(1); } return 0; } - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
线程的条件变量
什么是条件变量？
- 与互斥锁不同，条件变量是用来等待而不是用来上锁的。条件变量用来自动阻塞一个线程，直到某种情况发生为止，
通常条件变量和互斥锁一起使用。 - 条件变量使我们可以睡眠来等待某种条件出现。条件变量是
利用线程间共享的全局变量进行同步的一种机制，主要包括两个动作: - 线程因等待"条件变量的条件成立"而被挂起；
- 线程使"条件成立"(给出条件成立信号)。
- 条件的检测是在
互斥锁的保护下进行的。如果条件为假，一个线程自动阻塞(挂起)，并释放等待状态改变的互斥锁。 - 如果另一个线程改变了条件，它发信号给关联的条件变量，唤醒一个或多个等待它的线程，重新获得互斥锁，重新评价条件。
- 如果两个进程共享可读写的内存，条件变量可以被用来实现这两个进程间的线程同步。
条件变量初始化
- pthread_cond_init
- 功能:初始化条件变量
- 函数原型:int pthread_cond_init (pthread_cond_t *cond, const pthread_condattr_t *attr);
- 参数:
- cond:要操作的条件变量。
- attr:设置条件变量属性。
- 返回值:
- 成功:返回0。
- 失败:返回错误码。
唤醒一个等待线程
- pthread_cond_signal
- 功能:通知条件变量，唤醒一个等待者。
- 函数原型: int pthread_cond_signal (pthread_cond_t *cond);
- 参数:
- cond:要操作的条件变量(条件变量指针)。
- 返回值:
- 成功:返回0。
- 失败:返回错误码。
唤醒所有等待该条件变量的线程
- pthread_cond_broadcast
- 功能:广播条件变量。
- 函数原型: int pthread_cond_broadcast (pthread_cond_t *cond);
- 参数:
- cond:要操作的条件变量。
- 返回值:
- 成功:返回0。
- 失败:返回错误码。
等待条件变量/超时被唤醒
- pthread_cond_timedwait
- 功能:等待条件变量cond被唤醒，直到由一个信号或广播，或到绝对超时时间abstime，才唤醒该线程。
- 函数原型:int pthread_cond_timedwait (pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime);
- 参数：
- cond:要操作的条件变量:
- mutex:互斥量。
- 返回值:
- 成功:返回0。
- 失败:返回错误码。
等待条件变量被唤醒
- pthread_cond_wait
- 功能:等待条件变量cond被唤醒(由一个信号或广播)。
- 函数原型:int pthread_cond_wait (pthread_cond_t *cond, pthread_mutex_t *mutex);
- 参数:
- cond:要操作的条件变量。
- mutex:互斥量。
- 返回值:
- 成功:返回0。
- 失败:返回错误码。
释放/销毁条件变量
- pthread_cond_destroy
- 功能:销毁条件变量。
- 函数原型:int pthread_cond_destroy (pthread_cond_t *cond);
- 参数:
- cond:要销毁的条件变量。
- 返回值:
- 成功:返回0。
- 失败:返回错误码。
示例：
个人理解，条件变量会为临界资源创建两道防线，第一道防线为进入等待唤醒前，第二道为进入临界区前。- 条件变量与互斥量的结合。
- 进入到第一道防线时，pthread_mutex_lock对互斥量加锁(P操作)。
- 进入到第一道防线后，也就是等待被唤醒前，pthread_cond_wait首先会先将当前线程挂起，然后解锁互斥量(V操作)。
- 被唤醒时，pthread_cond_wait首先对互斥量加锁，然后线程才被唤醒(第二道防线也突破)，执行完临界区中的代码后，再次解锁。
如下图示中，注意:- 我们默认该进程有两个额外创建的线程，线程1首先执行。
- 图中仅示例线程1和线程2分别执行一次。
#include#include pthread_mutex_t mutex;//互斥量 pthread_cond_t cond;//条件变量 void *thread1(void *arg){ while (1) { printf("thread1 is running\n"); pthread_mutex_lock(&mutex);//加锁 pthread_cond_wait(&cond, &mutex);//等待时挂起，然后开锁，被唤醒时，先加锁，然后再唤醒(即执行下方代码)。。 printf("thread1 applied the condition\n"); pthread_mutex_unlock(&mutex);//开锁 sleep(4); } } void *thread2(void *arg){ while (1) { printf("thread2 is running\n"); pthread_mutex_lock(&mutex);//加锁 pthread_cond_wait(&cond, &mutex);//等待时挂起，然后开锁，被唤醒时，先加锁，然后再唤醒(即执行下方代码)。 printf("thread2 applied the condition\n"); pthread_mutex_unlock(&mutex);//开锁 sleep(2); } } int main(){ pthread_t thid1, thid2; printf("condition variable study!\n"); pthread_mutex_init(&mutex, NULL);//互斥量初始化 pthread_cond_init(&cond, NULL);//条件变量初始化 pthread_create(&thid1, NULL, (void *)thread1, NULL);//线程1创建 pthread_create(&thid2, NULL, (void *)thread2, NULL);//线程2创建 do { pthread_cond_signal(&cond);//唤醒一个等待线程 sleep(1); } while (1); return 0; } - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
-
相关阅读:
【pytorch】1.6 tensor 计算
vue3 和vue2 的比较
AI数字人软件系统开发框架
PL/SQL基础知识点（一）
JAVA基础知识总结三
CF1114F Please, another Queries on Array?【线段树+欧拉函数】
反射课后习题及做题记录
Transformer的最简洁pytorch实现
VB.NET三层之用户查询窗体
java-php-python+nodejs+vue生物遗传病的治疗和防范系统
- 原文地址：https://blog.csdn.net/qq_51604330/article/details/126566582
