Linux多进程和多线程(八)多线程

  • 多线程
    • 线程定义
    • 线程与进程
    • 线程资源
  • 线程相关命令
    • pidstat 命令
  • top 命令
  • ps 命令
  • 常见的并发方案
    • 1. 多进程模式
    • 2. 多线程模式
  • 创建线程
    • 1. pthread_create()
      • 示例:创建一个线程
    • 2. pthread_exit() 退出线程
    • 3. pthread_join() 等待线程结束
      • 示例:
    • 线程分离
  • 创建多个线程
    • 示例 1:创建多个线程执行不同的任务
    • 示例 2:创建多个线程执行相同的任务
  • 线程间的通讯
    • 主线程向子线程传递参数
    • 子线程向主线程传递参数
      • 示例:
  • 线程互斥锁
    • 线程互斥锁
    • 互斥锁的原理
    • 互斥锁的特点
    • 互斥锁的使用
      • 静态初始化
      • 动态初始化
        • pthread_mutex_init()函数
        • pthread_mutex_destroy()函数
  • 线程同步
    • ⽣产者与消费者问题
    • 示例 基于互斥锁实现⽣产者与消费者模型
  • 条件变量
    • 条件变量初始化
      • 静态初始化
      • 动态初始化 pthread_cond_init()
      • pthread_cond_destroy()
    • 条件变量的使用
      • 等待 pthread_cond_wait()
      • 通知 pthread_cond_signal()
      • 通知所有 pthread_cond_broadcast()
    • 示例 基于条件变量实现⽣产者与消费者模型

多线程

线程定义

线程是进程中的⼀个执⾏单元，

负责当前进程中程序的执⾏，

⼀个进程中⾄少有⼀个线程

⼀个进程中是可以有多个线程

多个线程共享同一个进程的所有资源，每个线程参与操作系统的统一调度

可以简单理解成 进程 = 内存资源 + 主线程 + 子线程 +…

线程与进程

联系比较紧密的任务,在并发时,优先选择多线程,任务联系不紧密,比较独立的任务,建议选择多进程;

  • 进程：操作系统分配资源的基本单位，是资源分配的最小单位，是程序的执行和调度单位，是程序的运行实例。
  • 线程：是CPU调度和分派的基本单位，是CPU执行的最小单位，是程序执行流的最小单元，是程序执行的最小单位。

线程与进程区别:

  • 内存空间
    • 一个进程中多个线程共享同一个内存空间
    • 多个进程拥有独立的内存空间
  • 进程/线程间通讯
    • 线程间通讯方式简单
    • 进程间通讯方式复杂

线程资源

  • 共享进程的资源
    • 同一块地址空间
    • 文件描述符表
    • 每种信号的处理方式
    • 当前工作目录
    • 用户id和组id
  • 独有资源
    • 线程栈
    • 每个线程都有私有的上下文信息
    • 线程id
    • 寄存器的值
    • errno值
    • 信号屏蔽字以及调度优先级

线程相关命令

在 Linux 系统有很多命令可以查看进程，包括 pidstat 、top 、ps ，可以查看进程，也可以查看一个
进程下的线程

pidstat 命令

ubuntu 下需要安装 sysstat 工具之后，可以支持 pidstat

sudo apt install sysstat

选项

-t : 显示指定进程所关联的线程

-p : 指定 进程 pid

示例

查看进程 12345 所关联的线程

sudo pidstat -t -p 12345

查看所有进程所关联的线程

sudo pidstat -t

查看进程 12345 所关联的线程，每隔 1 秒输出一次

sudo pidstat -t -p 12345 1

查看所有进程所关联的线程，每隔 1 秒输出一次

sudo pidstat -t 1

top 命令

top 命令查看某一个进程下的线程，需要用到 -H 选项在结合 -p 指定 pid

选项

-H : 显示线程信息

-p : 指定 进程 pid

示例

查看进程 12345 所关联的线程

sudo top -H -p 12345

查看所有进程所关联的线程

sudo top -H

ps 命令

ps 命令结合 -T 选项就可以查看某个进程下所有线程

选项

-T : 显示线程信息

-p : 指定 进程 pid

示例

查看进程 12345 所关联的线程

sudo ps -T -p 12345

查看所有进程所关联的线程

sudo ps -T

常见的并发方案

1. 多进程模式

多进程模式下，每个进程负责不同的任务，互不干扰，各自运行在不同的内存空间，互不影响。

  • 优点：
    • 进程的地址空间独立,一旦某个进程出现异常,不会影响其他进程
  • 缺点:
    • 每个进程都需要分配独立的内存空间,创建进程的代价高,占用更多的内存
    • 进程间协同,进程间通讯比较复杂
  • 适用场景:
    • 多个任务联系不是非常紧密,可以采用多进程模式
    • 任务之间没有依赖关系,可以采用多进程模式

2. 多线程模式

多线程模式下，一个进程内可以有多个线程，共享同一份内存空间，线程之间可以直接通信。

  • 优点:
    • 线程间通信简单
    • 同一个进程的多个线程可以共享资源,可以提高资源利用率
  • 缺点:
    • 线程没有独立的进程地址空间,主线程退出后,其他线程也会退出
    • 线程切换和调度需要消耗资源,线程数量过多,会消耗系统资源
    • 线程间同步复杂,需要考虑线程安全问题
  • 适用场景:
    • 任务之间有依赖关系,可以采用多线程模式
    • 任务之间通信比较频繁,可以采用多线程模式

创建线程

1. pthread_create()

pthread_create() 用来创建线程，创建成功后，线程就开始运行，
pthread_create() 调用成功后，会返回 0，否则返回错误码。

函数头文件:

#include <pthread.h>int pthread_create(pthread_t *thread, const pthread_attr_t *attr,void *(*start_routine) (void *), void *arg);

参数说明:

  • thread: 指向 pthread_t 类型的指针，用来存储线程的 ID。
  • attr: 线程属性，可以为 NULL，表示使用默认属性。
  • start_routine: 线程的入口函数.
  • arg: 传递给线程入口函数的参数。

返回值:

  • 0: 创建成功。
  • EAGAIN: 资源不足，创建线程失败。
  • EINVAL: 参数无效。
  • ENOMEM: 内存不足，创建线程失败。

注意:

  • 一旦子线程创建成功,则会被独立调度执行,并且与其他线程 并发执行
  • 在编译时需要链接 -lpthread 库。

示例:创建一个线程

// todo : 创建一个线程，并在线程中打印出“Hello, World!”
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>// 线程函数
//@param arg 线程函数参数
void * print_hello(void *arg) {printf("%s\n",(char *)arg);
}int main() {pthread_t tid; //? typedef unsigned long int pthread_t;// 创建线程//@param tid 线程ID//@param attr 线程属性//@param start_routine 线程函数//@param arg 线程函数参数int ret = pthread_create(&tid, NULL,print_hello, "Hello, World!");if (ret!= 0){printf("pthread_create error!\n");return 1;}sleep(1); // 等待线程执行完毕return 0;
}

2. pthread_exit() 退出线程

pthread_exit() 用来退出线程，线程执行完毕后，会自动调用 pthread_exit() 退出。

函数头文件:

#include <pthread.h>void pthread_exit(void *retval);

参数说明:

  • retval: 线程退出时返回的值。
  • 线程函数执行完毕后，会自动调用 pthread_exit() 退出。

3. pthread_join() 等待线程结束

pthread_join() 用来等待线程结束，
调用 pthread_join() 后，当前线程会被阻塞，直到线程结束。

函数头文件:

#include <pthread.h>int pthread_join(pthread_t thread, void **retval);

参数说明:

  • thread: 线程 ID。
  • retval: 指向线程返回值的指针，用来存储线程退出时返回的值。(二级指针)

返回值:

  • 0: 等待成功。
  • EINVAL: 参数无效。
  • ESRCH: 线程 ID 不存在。
  • EDEADLK: 线程处于死锁状态。

示例:

// todo : 创建一个线程，并在线程中打印出“Hello, World!”
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>// 线程函数
//@param arg 线程函数参数
void * print_hello(void *arg) {sleep(1); // 休眠1秒printf("%s\n",(char *)arg);pthread_exit(NULL); // 线程退出
}int main() {pthread_t tid; //? typedef unsigned long int pthread_t;// 创建线程//* @param tid 线程ID//* @param attr 线程属性//* @param start_routine 线程函数//* @param arg 线程函数参数int ret = pthread_create(&tid, NULL,print_hello, "Hello, World!");if (ret!= 0){printf("pthread_create error!\n");return 1;}printf("等待线程结束...\n");// 等待线程结束//* @param thread 线程ID//* @param status 线程退出状态pthread_join(tid, NULL);return 0;
}

等待线程结束...
Hello, World!

线程分离

线程分为可结合的与可分离的

  • 可结合
    • 可结合的线程能够被其他线程收回其资源和杀死；在被其他线程回收之前，它的存储器资源（如栈）是不释放的。
    • 线程创建的默认状态为 可结合的，可以由其他线程调用 pthread_join 函数等待子线程退出并释放相关资源
  • 可分离
    • 不能被其他线程回收或者杀死的，该线程的资源在它终止时由系统来释放。
// todo : 创建一个线程，并在线程中打印出“Hello, World!”
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>// 线程函数
//@param arg 线程函数参数
void * print_hello(void *arg) {sleep(1); // 休眠1秒printf("%s\n",(char *)arg);pthread_exit(NULL); // 线程退出
}int main() {pthread_t tid; //? typedef unsigned long int pthread_t;// 创建线程//* @param tid 线程ID//* @param attr 线程属性//* @param start_routine 线程函数//* @param arg 线程函数参数int ret = pthread_create(&tid, NULL,print_hello, "Hello, World!");if (ret!= 0){printf("pthread_create error!\n");return 1;}printf("等待线程结束...\n");// 等待线程结束//* @param thread 线程ID//* @param status 线程退出状态//pthread_join(tid, NULL);//! 阻塞等待线程结束，直到线程结束后才继续往下执行//线程分离pthread_detach(tid); //! 分离线程，不用等待线程结束后才退出程序,该线程的资源在它终止时由系统来释放。printf("主线程结束\n");return 0;
}

创建多个线程

示例 1:创建多个线程执行不同的任务

// todo : 创建多个线程,执行不同的任务
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>// 线程函数
//@param arg 线程函数参数
void * print_hello_A(void *arg) {sleep(1); // 休眠1秒printf("%s\n",(char *)arg);pthread_exit(NULL); // 线程退出
}
// 线程函数
//@param arg 线程函数参数
void * print_hello_B(void *arg) {sleep(2); // 休眠2秒printf("%s\n",(char *)arg);pthread_exit(NULL); // 线程退出
}int main() {pthread_t tidA; //? 存储线程ID  typedef unsigned long int pthread_t;pthread_t tidB;// 创建线程//* @param tid 线程ID//* @param attr 线程属性//* @param start_routine 线程函数//* @param arg 线程函数参数int retA = pthread_create(&tidA, NULL,print_hello_A, "A_ Hello, World!");if (retA!= 0){printf("pthread_create error!\n");return 1;}int retB = pthread_create(&tidB, NULL,print_hello_B, "B_ Hello, World!");if (retB!= 0){printf("pthread_create error!\n");return 1;}printf("等待线程结束...\n");// 等待线程结束//* @param thread 线程ID//* @param status 线程退出状态pthread_join(tidA, NULL);//! 阻塞等待线程结束，直到线程结束后才继续往下执行pthread_join(tidB, NULL);printf("主线程结束\n");return 0;
}

示例 2:创建多个线程执行相同的任务

// todo : 创建多个线程,执行相同任务
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
//? 两个线程执行相同任务,对函数中的值修改了,会不会影响到其他线程的执行?
//! 在多线程编程中，如果多个线程执行相同的任务并且对共享资源进行修改，可能会影响到其他线程的执行。
//! 这是因为多个线程共享相同的内存空间，对共享资源的修改可能会导致竞态条件（race condition），
//! 从而导致不可预测的行为。
//! print_hello函数中的变量i是局部变量，每个线程都会有自己的i副本，因此对i的修改不会影响到其他线程。
//! 但是，如果涉及到共享资源（例如全局变量或静态变量），就需要考虑线程同步的问题，以避免竞态条件。//*局部变量：每个线程都有自己的栈空间，因此局部变量是线程私有的，不会影响到其他线程。
//*共享资源：如果多个线程访问和修改同一个全局变量或静态变量，就需要使用同步机制（如互斥锁、信号量等）来确保线程安全。
//Linux：在Linux系统中，默认的线程栈大小通常是8MB。可以使用ulimit -s命令查看和修改当前用户的线程栈大小。例如，ulimit -s 1024将线程栈大小设置为1MB。
//Windows：在Windows系统中，默认的线程栈大小是1MB。可以通过编译器选项或在创建线程时指定栈大小来修改。// 线程函数
//@param arg 线程函数参数
void * print_hello(void *arg) {for (char i = 'a'; i < 'z' ; ++i) {printf("%c\n", i);sleep(1); // 休眠1秒}pthread_exit(NULL); // 线程退出
}int main() {pthread_t tid[2]={0}; //? 存储线程ID的数组  typedef unsigned long int pthread_t;for (int i = 0; i < 2; ++i) {// 创建线程//* @param tid 线程ID//* @param attr 线程属性//* @param start_routine 线程函数//* @param arg 线程函数参数int retA = pthread_create(&tid[i], NULL,print_hello, NULL);if (retA!= 0){printf("pthread_create error!\n");return 1;}}printf("等待线程结束...\n");// 等待线程结束//* @param thread 线程ID//* @param status 线程退出状态pthread_join(tid[0], NULL);//! 阻塞等待线程结束，直到线程结束后才继续往下执行pthread_join(tid[1], NULL);printf("主线程结束\n");return 0;
}

线程间的通讯

进程间的其他通讯同样适用于线程间的通讯。

主线程向子线程传递参数

通过pthread_create()函数创建子线程时，pthread_create()的第四个参数是传递给子线程的函数的参数。

子线程向主线程传递参数

通过pthread_exit()函数退出子线程时，可以向主线程传递参数。

void pth_exit(void *retval);

通过pthread_join()函数等待子线程结束时，获取子线程的返回参数.

int pthread_join (pthread_t __th, void **__thread_return);
//二级指针获取到了pthread_exit()函数参数指针的指向地址，通过该地址可以获取到子线程的返回参数。

示例:

// todo : 线程直接通讯,子线程向父线程传参
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>// 线程函数
//@param arg 线程函数参数
void * print_hello(void *arg) {printf("子线程开始,结束之时传递参数100的地址\n");sleep(1); // 休眠1秒//! int num=100;//局部变量,函数结束释放内存static int num=100;//* 静态局部变量,函数结束不释放内存,延长生命周期pthread_exit(&num); // 线程退出
}int main() {pthread_t tid; //? 存储线程ID  typedef unsigned long int pthread_t;// 创建线程//* @param tid 线程ID//* @param attr 线程属性//* @param start_routine 线程函数//* @param arg 线程函数参数int retA = pthread_create(&tid, NULL,print_hello, NULL);if (retA!= 0){printf("pthread_create error!\n");return 1;}printf("等待线程结束...\n");void* num;//获取子进程传递的参数,num指向了子进程传递的参数// 等待线程结束//* @param thread 线程ID//* @param status 线程退出状态pthread_join(tid, (void **)&num);//! 阻塞等待线程结束，直到线程结束后才继续往下执行printf("子线程结束,传递的参数为%d\n",*(int*)num);printf("主线程结束\n");return 0;
}

线程互斥锁

线程互斥锁

互斥锁（Mutex）是一种同步机制，用来控制对共享资源的访问。

线程的主要优势在于，能够通过全局变量来共享信息, 不过这种便捷的共享是有代价的:

必须确保多个线程不会同时修改同⼀变量

某⼀线程不会读取正由其他线程修改的变量, 实际就是不能让两个线程同时对临界区进⾏访问

互斥锁的原理

互斥锁的原理是，当一个线程试图进入一个互斥区时，如果该互斥区已经被其他线程占用，则该线程将被阻塞，直到互斥区被释放。

本质上是一个pthread_mutex_t类型的变量，它包含一个整数值，用来表示互斥区的状态。
当值为1时,则表示当前临界资源可以竞争访问,得到互斥锁的线程可以进入临界区。此时值为0,其他线程只能等待.
当值为0时,则表示当前临界资源被其他线程占用,不能进入临界区,只能等待.

互斥锁的特点

typedef union
{struct __pthread_mutex_s __data; // 互斥锁的结构体char __size[__SIZEOF_PTHREAD_MUTEX_T];// 互斥锁的大小long int __align;// 互斥锁的对齐
} pthread_mutex_t;
  • 互斥锁是⼀个 pthread_mutex_t 型的变量, 就代表⼀个 互斥锁
  • 如果两个线程访问的是同⼀个 pthread_mutex_t 变量，那么它们访问了同⼀个互斥锁
  • 对应的变量定义在 pthreadtypes.h 头⽂件中, 是⼀个共⽤体中包含⼀个结构体

互斥锁的使用

线程互斥锁的初始化⽅式主要分为两种:

静态初始化

  • 定义 pthread_mutex_t 类型的变量，然后对其初始化为 PTHREAD_MUTEX_INITIALIZER.
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER

动态初始化

动态初始化动态初始化主要涉及两个函数 pthread_mutex_init 函数 与pthread_mutex_destroy 函数

pthread_mutex_init()函数

用来初始化互斥锁，它接受两个参数: 互斥锁的地址和互斥锁的属性。

函数头文件:

#include <pthread.h>int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);

参数说明:

  • mutex: 指向 pthread_mutex_t 类型的指针，用来存储互斥锁的地址。
  • attr: 互斥锁的属性，可以为 NULL，表示使用默认属性。

返回值:

  • 0: 初始化成功。
  • 失败返回错误码。
pthread_mutex_destroy()函数

用来销毁互斥锁，它接受一个参数: 互斥锁的地址。

函数头文件:

#include <pthread.h>int pthread_mutex_destroy(pthread_mutex_t *mutex);

参数说明:

  • mutex: 指向 pthread_mutex_t 类型的指针，用来存储互斥锁的地址。

返回值:

  • 0: 销毁成功。
  • 失败返回错误码。

示例:

// todo :  互斥锁;创建两个线程，分别对全局变量进⾏ +1 操作
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>static int global = 0;// 全局变量//静态初始化互斥锁
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;// 互斥锁
//动态初始化互斥锁
pthread_mutex_t mut;// 互斥锁// 线程函数
//@param arg 线程函数参数
void * print_hello(void *arg) {printf("子线程开始\n");int loops = *(int *)arg;int i,tmp = 0;for (i = 0;i < loops;i++){pthread_mutex_lock(&mut);// 加锁printf("子线程%d,global=%d\n",i,global);tmp = global;tmp++;global = tmp;pthread_mutex_unlock(&mut);// 解锁}printf("子线程结束\n");pthread_exit(NULL); // 线程退出
}int main() {// 动态初始化互斥锁//* @param mutex 互斥锁//* @param attr 互斥锁属性 NULL 是默认属性int r= pthread_mutex_init(&mut,NULL);if (r!= 0){printf("pthread_mutex_init error!\n");return 1;}pthread_t tid[2]={0}; //? 存储线程ID  typedef unsigned long int pthread_t;int arg=20;for (int i = 0; i < 2; i++){// 创建线程//* @param tid 线程ID//* @param attr 线程属性//* @param start_routine 线程函数//* @param arg 线程函数参数int retA = pthread_create(&tid[i], NULL,print_hello, &arg);if (retA!= 0){printf("pthread_create error!\n");return 1;}}printf("等待线程结束...\n");// 等待线程结束//* @param thread 线程ID//* @param status 线程退出状态pthread_join(tid[0],NULL );//! 阻塞等待线程结束，直到线程结束后才继续往下执行pthread_join(tid[1],NULL );printf("%d\n",global);printf("主线程结束\n");// 销毁动态创建的互斥锁//* @param mutex 互斥锁pthread_mutex_destroy(&mut);// 销毁互斥锁return 0;
}

线程同步

线程同步 : 是指在互斥的基础上（⼤多数情况），通过其它机制实现访问者对 资源的有序访问.

条件变量 ： 线程库提供的专⻔针对线程同步的机制

线程同步⽐较典型的应⽤场合就是 ⽣产者与消费者

⽣产者与消费者问题

在这个模型中, 分为 ⽣产者线程 与 消费者线程, 通过这个线程来模拟多个线程同步的过程.

在这个模型中, 需要以下组件:

  • 仓库 : ⽤于存储产品, ⼀般作为共享资源
  • ⽣产者线程 : ⽤于⽣产产品
  • 消费者线程 : ⽤于消费产品

原理:

当仓库没有产品时, 则消费者线程需要等待, 直到有产品时才能消费

当仓库已经装满产品时, 则⽣产者线程需要等待, 直到消费者线程消费产品之后

示例 基于互斥锁实现⽣产者与消费者模型

主线程为消费者

n 个⼦线程作为⽣产者

// todo :  基于互斥锁实现⽣产者与消费者模型主线程为消费者,n 个⼦线程作为⽣产者
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
static int n = 0; // 产品数量
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;// 互斥锁//生产者执行函数
void * dofunc(void *arg) {int arg1 = *(int*)arg;for (int i = 0; i <arg1; i++) {//获取互斥锁pthread_mutex_lock(&mutex);//生产产品printf("生产者%ld生产了%d个产品\n",pthread_self(),++n);//! pthread_self()返回当前线程ID//释放互斥锁pthread_mutex_unlock(&mutex);//休眠1秒sleep(1);}pthread_exit(NULL);
}int main() {pthread_t tid[4]={0}; //? 存储线程ID  typedef unsigned long int pthread_t;int arr[4]={1,2,3,4};for (int i = 0; i < 4; i++) {// 创建线程//* @param tid 线程ID//* @param attr 线程属性//* @param start_routine 线程函数//* @param arg 线程函数参数int retA = pthread_create(&tid[i], NULL,dofunc,&arr[i] );if (retA!= 0){printf("pthread_create error!\n");return 1;}}//消费者执行for (int i = 0;i<10;i++) {//获取互斥锁pthread_mutex_lock(&mutex);while (n > 0){//消费产品printf("消费者%ld消费了1个产品:%d\n",pthread_self(),n--);}//释放互斥锁pthread_mutex_unlock(&mutex);//休眠1秒sleep(1);}printf("等待线程结束...\n");// 等待线程结束//* @param thread 线程ID//* @param status 线程退出状态pthread_join(tid[0],NULL );//! 阻塞等待线程结束，直到线程结束后才继续往下执行pthread_join(tid[1],NULL );pthread_join(tid[2],NULL );pthread_join(tid[3],NULL );return 0;
}

条件变量

条件变量是⼀种同步机制，它允许线程等待某个条件的⽬标满足后才继续运行。

条件变量的原理是，它包含一个互斥锁和一个等待队列。

互斥锁用于保护等待队列和条件变量。

在这里插入图片描述

条件变量初始化

条件变量的本质为 pthread_cond_t 类型

其他线程可以阻塞在这个条件变量上, 或者唤
醒阻塞在这个条件变量上的线程
typedef union
{struct __pthread_cond_s __data;char __size[__SIZEOF_PTHREAD_COND_T];__extension__ long long int __align;
} pthread_cond_t;

条件变量的初始化分为 静态初始化 与动态初始化

静态初始化

静态初始化的条件变量，需要先定义一个 pthread_cond_t 类型的变量，然后对其初始化为 PTHREAD_COND_INITIALIZER。

pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

动态初始化 pthread_cond_init()

动态初始化的条件变量，需要先定义一个 pthread_cond_t 类型的变量，然后调用 pthread_cond_init 函数对其进行初始化。

函数头文件:

#include <pthread.h>int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);

参数说明:

  • cond: 指向 pthread_cond_t 类型的指针，用来存储条件变量的地址。
  • attr: 条件变量的属性，可以为 NULL，表示使用默认属性。

返回值:

  • 0: 初始化成功。
  • 失败返回错误码。

pthread_cond_destroy()

用来销毁条件变量，它接受一个参数: 条件变量的地址。

函数头文件:

#include <pthread.h>int pthread_cond_destroy(pthread_cond_t *cond);

参数说明:

  • cond: 指向 pthread_cond_t 类型的指针，用来存储条件变量的地址。

返回值:

  • 0: 销毁成功。
  • 失败返回错误码。

条件变量的使用

条件变量的使用分为 等待 与 通知

等待 pthread_cond_wait()

等待函数 pthread_cond_wait() 接受三个参数: 条件变量的地址、互斥锁的地址、等待时间。

函数头文件:

#include <pthread.h>int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime);

参数说明:

  • cond: 指向 pthread_cond_t 类型的指针，用来存储条件变量的地址。
  • mutex: 指向 pthread_mutex_t 类型的指针，用来存储互斥锁的地址。
  • abstime: 超时时间，可以为 NULL，表示没有超时时间。

返回值:

  • 0: 等待成功。
  • 失败返回错误码。

通知 pthread_cond_signal()

通知函数
pthread_cond_signal() 接受一个参数: 条件变量的地址。

函数头文件:

#include <pthread.h>int pthread_cond_signal(pthread_cond_t *cond);

参数说明:

  • cond: 指向 pthread_cond_t 类型的指针，用来存储条件变量的地址。

返回值:

  • 0: 通知成功。
  • 失败返回错误码。

通知所有 pthread_cond_broadcast()

通知所有函数
pthread_cond_broadcast() 接受一个参数: 条件变量的地址。

函数头文件:

#include <pthread.h>int pthread_cond_broadcast(pthread_cond_t *cond);

参数说明:

  • cond: 指向 pthread_cond_t 类型的指针，用来存储条件变量的地址。

返回值:

  • 0: 通知成功。
  • 失败返回错误码。

示例 基于条件变量实现⽣产者与消费者模型

在这里插入图片描述

step 1 : 消费者线程判断消费条件是否满足 (仓库是否有产品)，如果有产品可以消费，则可以正
常消费产品，然后解锁
step 2 : 当条件不能满足时 (仓库产品数量为 0)，则调用 pthread_cond_wait 函数, 这个函数具体做的事情如下:在线程睡眠之前，对互斥锁解锁让线程进⼊到睡眠状态等待条件变量收到信号时 唤醒，该函数重新竞争锁，并获取锁后，函数返回 
step 3 ：重新判断条件是否满足, 如果不满足，则继续调用 pthread_cond_wait 函数
step 4 : 唤醒后，从 pthread_cond_wait 返回，消费条件满足，则正常消费产品
step 5 : 释放锁，整个过程结束

为什么条件变量需要与互斥锁结合起来使⽤?

保护共享数据：

互斥锁用于保护共享数据，确保在同一时间只有一个线程可以访问和修改这些数据。

这样可以避免数据竞争和不一致的问题。

条件变量用于线程间的通信，通知其他线程某个条件已经满足。

但是，条件变量的操作本身并不提供对共享数据的保护，因此需要与互斥锁结合使用。

避免虚假唤醒：

条件变量的一个特性是可能会发生虚假唤醒（Spurious Wakeup），

即线程在没有明确通知的情况下被唤醒。为了避免这种情况导致的错误操作，

线程在唤醒后需要重新检查条件是否真正满足。

使用互斥锁可以确保在检查条件时，共享数据不会被其他线程修改，从而避免因虚假唤醒导致的错误。

确保通知的正确性：

当一个线程通过条件变量通知其他线程时，需要确保在通知之前共享数据已经更新完毕。

互斥锁可以保证这一点，确保在释放锁之前所有数据更新操作都已经完成。

同样，接收通知的线程在检查条件之前也需要持有互斥锁，以确保在检查条件时数据是稳定的。

实现复杂的同步模式：
结合使用互斥锁和条件变量可以实现更复杂的同步模式，如生产者-消费者问题、读者-写者问题等。互斥锁保护共享数据，条件变量用于线程间的协调和通信。

// todo :  条件变量
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <stdbool.h>
#include <stdlib.h>static int number = 0;// 产品数量
static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;// 互斥锁
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;// 条件变量// 线程函数
//@param arg 线程函数参数
void * thread_handler(void *arg) {int cnt = atoi((char *)arg);// 获取线程参数int i,tmp;// 临时变量for(i = 0;i < cnt;i++){// 生产产品pthread_mutex_lock(&mtx);// 上锁printf("线程 [%ld] ⽣产⼀个产品,产品数量为:%d\n",pthread_self(),++number);pthread_mutex_unlock(&mtx);// 解锁//! 唤醒cond阻塞的线程//! @param cond 条件变量//pthread_cond_signal(&cond);//! 只能唤醒一个线程，如果有多个线程在等待，则只有一个线程会被唤醒//唤醒所有线程pthread_cond_broadcast(&cond);}pthread_exit((void *)0);// 线程退出
}int main(int argc,char *argv[]) {pthread_t tid[argc-1];// 线程IDint i;int err;int total_of_produce = 0;// 总共生产的产品数量int total_of_consume = 0;// 总共消费的产品数量bool done = false;// 是否完成生产//循环创建线程for (i = 1;i < argc;i++){total_of_produce += atoi(argv[i]);// 计算总共需要生产的产品数量// 创建线程err = pthread_create(&tid[i-1],NULL,thread_handler,(void *)argv[i]);if (err != 0){perror("[ERROR] pthread_create(): ");exit(EXIT_FAILURE);}}//消费者for (;;){//*先获取锁,再进行条件变量的等待pthread_mutex_lock(&mtx);// 上锁//*while循环来判断条件,避免虚假唤醒while(number == 0) {// 等待生产者生产产品//! 等待条件变量//! @param cond 条件变量//! @param mtx 互斥锁//! 函数中会释放互斥锁，并阻塞线程，//! 直到条件变量被唤醒，再重新竞争互斥锁,获取互斥锁并继续执行pthread_cond_wait(&cond, &mtx);}while(number > 0){total_of_consume++;// 总共消费的产品数量printf("消费⼀个产品,产品数量为:%d\n",--number);// 消费产品done = total_of_consume >= total_of_produce;// 是否完成生产}pthread_mutex_unlock(&mtx);// 解锁if (done)// 是否完成生产break;}// 等待线程退出for(i = 0;i < argc-1;i++){pthread_join(tid[i],NULL);}return 0;}//循环创建线程for (i = 1;i < argc;i++){total_of_produce += atoi(argv[i]);// 计算总共需要生产的产品数量// 创建线程err = pthread_create(&tid[i-1],NULL,thread_handler,(void *)argv[i]);if (err != 0){perror("[ERROR] pthread_create(): ");exit(EXIT_FAILURE);}}//消费者for (;;){//*先获取锁,再进行条件变量的等待pthread_mutex_lock(&mtx);// 上锁//*while循环来判断条件,避免虚假唤醒while(number == 0) {// 等待生产者生产产品//! 等待条件变量//! @param cond 条件变量//! @param mtx 互斥锁//! 函数中会释放互斥锁，并阻塞线程，//! 直到条件变量被唤醒，再重新竞争互斥锁,获取互斥锁并继续执行pthread_cond_wait(&cond, &mtx);}while(number > 0){total_of_consume++;// 总共消费的产品数量printf("消费⼀个产品,产品数量为:%d\n",--number);// 消费产品done = total_of_consume >= total_of_produce;// 是否完成生产}pthread_mutex_unlock(&mtx);// 解锁if (done)// 是否完成生产break;}// 等待线程退出for(i = 0;i < argc-1;i++){pthread_join(tid[i],NULL);}return 0;}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/diannao/43824.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

前端面试题35（在iOS和Android平台上，实现WebSocket协议有哪些常见的库或框架？）

前端面试题35（在iOS和Android平台上，实现WebSocket协议有哪些常见的库或框架？）

在iOS和Android平台上&#xff0c;实现WebSocket协议有许多成熟且被广泛使用的库和框架。下面是一些推荐的选项&#xff1a; iOS 平台 SocketRocket 简介&#xff1a;这是由Facebook开源的库&#xff0c;专门为iOS和Mac OS X设计&#xff0c;提供WebSocket连接的功能。它基于S…
阅读更多...
Blender新手入门笔记收容所（一）

Blender新手入门笔记收容所（一）

基础篇 基础操作 视角的控制 控制观察视角&#xff1a;鼠标中键平移视图&#xff1a;Shift鼠标中键缩放视图&#xff1a;滚动鼠标中键滚轮 选中物体后&#xff1a;移动物体快捷键G&#xff0c;移动后单击鼠标就会定下来。 进入移动状态后&#xff1a;按Y会沿着Y轴移动进入移动…
阅读更多...
HW期间——应急响应

HW期间——应急响应

01HW中应急响应的流程 001应急响应所处位置&#xff08;应急处置组&#xff09; 监控研判组发现的一些安全时间提供给应急处置组&#xff0c;应急处置组通过上机取证把线索给到溯源反制组。但是溯源反制组可能已经没有了&#xff0c;有些单位有&#xff0c;有些单位取消了。有…
阅读更多...
Python神经模型评估微分方程图算法

Python神经模型评估微分方程图算法

&#x1f3af;要点 &#x1f3af;神经网络映射关联图 | &#x1f3af;执行时间分析 | &#x1f3af;神经网络结构降维 | &#x1f3af;量化图结构边作用 | &#x1f3af;数学评估算法实现 &#x1f36a;语言内容分比 &#x1f347;Python随机梯度下降算法 随机梯度下降是梯度…
阅读更多...
matlab仿真 通信信号和系统分析（下）

matlab仿真 通信信号和系统分析（下）

&#xff08;内容源自详解MATLAB&#xff0f;SIMULINK 通信系统建模与仿真 刘学勇编著第三章内容&#xff0c;有兴趣的读者请阅读原书&#xff09; 一、离散傅里叶变换 clear all n0:30;%信号的时间范围 xsin(0.2*n).*exp(-0.1*n); k0:30;%频率范围 N31; Wnkexp(-j*2*pi/N).…
阅读更多...
解决本地操作云服务器上的Redis

解决本地操作云服务器上的Redis

方案一&#xff1a;开放Redis默认端口&#xff0c;本地通过公网IP端口号的形式访问。 方案二&#xff1a;每次将本地编写好的Java代码打包&#xff0c;放在云服务器上运行。 方案三&#xff1a;配置ssh端口转发&#xff0c;把云服务器的redis端口&#xff0c;映射到本地主机。 …
阅读更多...
【大模型】微调实战—使用 ORPO 微调 Llama 3

【大模型】微调实战—使用 ORPO 微调 Llama 3

ORPO 是一种新颖微调&#xff08;fine-tuning&#xff09;技术&#xff0c;它将传统的监督微调&#xff08;supervised fine-tuning&#xff09;和偏好对齐&#xff08;preference alignment&#xff09;阶段合并为一个过程。这减少了训练所需的计算资源和时间。此外&#xff0…
阅读更多...
使用微pe装系统

使用微pe装系统

本文仅作为记录&#xff0c;不作为教程。 今天心血来潮想下点游戏玩玩&#xff0c;一看之前分的200gc盘已经红了&#xff0c;再加上大学之后这个笔记本已经用得很少了&#xff0c;于是打算重装电脑。 参考: 微PE辅助安装_哔哩哔哩_bilibil… 1.下载微pe和win10系统到U盘 我这…
阅读更多...
Xilinx zc706 USB电路解析

Xilinx zc706 USB电路解析

作者 QQ群&#xff1a;852283276 微信&#xff1a;arm80x86 微信公众号&#xff1a;青儿创客基地 B站&#xff1a;主页 https://space.bilibili.com/208826118 参考 USB OTG检测原理 USB3320 USB_ID为低电平时候&#xff0c;为host模式&#xff0c;USB_ID为悬空&#xff08;高…
阅读更多...
python-23-零基础自学python open()和replace（）函数运用

python-23-零基础自学python open()和replace（）函数运用

学习内容&#xff1a;《python编程&#xff1a;从入门到实践》第二版练习10-2 知识点&#xff1a; 打开文件&#xff0c;replace()替换文件内容&#xff0c;open(), 练习内容&#xff1a; 练习10-2:C语言学习笔记 可使用方法replace()将字符串中的特定单词都替换为另一个单…
阅读更多...
kafka系列之offset超强总结及消费后不提交offset情况的分析总结

kafka系列之offset超强总结及消费后不提交offset情况的分析总结

概述 每当我们调用Kafka的poll()方法或者使用Spring的KafkaListener(其实底层也是poll()方法)注解消费Kafka消息时&#xff0c;它都会返回之前被写入Kafka的记录&#xff0c;即我们组中的消费者还没有读过的记录。 这意味着我们有一种方法可以跟踪该组消费者读取过的记录。 如前…
阅读更多...
6.824/6.5840 的Debugging by Pretty Printing配置

6.824/6.5840 的Debugging by Pretty Printing配置

TA的原文在&#xff1a;Debugging by Pretty Printing (josejg.com) 为了在WSL2中配置好打印运行日志&#xff0c;我可是忙活了一下午。可恶的log配置 首先是安装rich库Textualize/rich: Rich is a Python library for rich text and beautiful formatting in the terminal. …
阅读更多...
用于视频生成的扩散模型

用于视频生成的扩散模型

学习自https://lilianweng.github.io/posts/2024-04-12-diffusion-video/ 文章目录 3D UNet和DiTVDMImagen VideoSora 调整图像模型生成视频Make-A-Video&#xff08;对视频数据微调&#xff09;Tune-A-VideoGen-1视频 LDMSVD稳定视频扩散 免训练Text2Video-ZeroControlVideo 参…
阅读更多...
需求分析｜泳道图 ProcessOn教学

需求分析｜泳道图 ProcessOn教学

文章目录 1.为什么使用泳道图2.具体例子一、如何绘制确定好泳道中枢的角色在中央基于事实来绘制过程不要纠结美观先画主干处理流程再画分支处理流程一个图表达不完&#xff0c;切分子流程过程数不超25 &#xff0c;A4纸的幅面处理过程过程用动词短语最后美化并加上序号酌情加上…
阅读更多...
后端——全局异常处理

后端——全局异常处理

一、老办法try-catch 当我们执行一些错误操作导致程序报错时&#xff0c;程序会捕捉到异常报错&#xff0c;这个异常会存在一个Exception对象里 那我们在spring boot工程开发时&#xff0c;当我们执行一个sql查询时报错了&#xff0c;那就会从最底层的Mapper层捕捉到Exceptio…
阅读更多...
Android应用程序调试Logcat的使用

Android应用程序调试Logcat的使用

Android的程序调试主要使用Logcat进行&#xff0c;本节主要介绍Logcat的使用。 开启调试模式 使用Android Studio进行程序调试&#xff0c;首先需要连接虚拟Android设备或真实Android设备&#xff0c;设备上需要启用调试功能。 虚拟Android设备默认情况下会启用调试功能。对…
阅读更多...
微软清华提出全新预训练范式，指令预训练让8B模型实力暴涨！实力碾压70B模型

微软清华提出全新预训练范式，指令预训练让8B模型实力暴涨！实力碾压70B模型

现在的大模型训练通常会包括两个阶段&#xff1a; 一是无监督的预训练&#xff0c;即通过因果语言建模预测下一个token生成的概率。该方法无需标注数据&#xff0c;这意味着可以利用大规模的数据学习到语言的通用特征和模式。 二是指令微调&#xff0c;即通过自然语言指令构建…
阅读更多...
通过高德地图 JS API实现单击鼠标进行标注

通过高德地图 JS API实现单击鼠标进行标注

效果图： 核心代码： <template><a-modal title="选择地图所在位置" :width="width" :visible="visible" @ok="handleOk" @cancel="handleCancel" cancelText="关闭"><div class="location-…
阅读更多...
场外期权有交割日吗？场外期权应该怎么交割？

场外期权有交割日吗？场外期权应该怎么交割？

今天带你了解场外期权有交割日吗&#xff1f;场外期权应该怎么交割&#xff1f;场外个股期权是一种非标准化的金融衍生品&#xff0c;它允许投资者在未来某一特定日期以特定价格买入或卖出某一特定股票。 交割日就是买卖双方进行交割的日期,期权合约具有到期日,到期日的后一天…
阅读更多...
C电池 和 D 电池的作用和类型详解及其之间的区别

C电池 和 D 电池的作用和类型详解及其之间的区别

C 和 D 电池是我们日常生活中必不可少的部件。它们通常用于高功率设备。例如手电筒和玩具。 D 型电池和 C 型电池是两种常见的电池类型。它们是一次性圆柱形电池。您可以在很多设备上使用它们。虽然它们有很多相似之处&#xff0c;但它们也有不同的特点。这些特点使它们适合某…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023