条件变量、线程池以及线程的GDB调试学习笔记

ssz__2024-01-29 17:43

目录

一、条件变量

二、线程池概念和实现

三、线程的GDB调试

一、条件变量

应用场景：生产者消费者问题，是线程同步的一种手段。

必要性：为了实现等待某个资源，让线程休眠，提高运行效率

使用步骤：

初始化：

  • 静态初始化

pthread_cond_t cond = PTHREAD_COND_INITIALIZER; //初始化条件变量

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; //初始化互斥量

  • 动态初始化

pthread_cond_init(&cond);

生产者线程：

  • pthread_mutex_lock(&mutex);
  • 开始生产资源
  • pthread_cond_signal(&cond); //通知一个消费线程

或者

  • pthread_cond_broadcast(&cond); //广播通知多个消费线程
  • pthread_mutex_unlock(&mutex);

消费者线程

  • pthread_mutex_lock(&mutex);

  • while （如果没有资源）{ //防止惊群效应

    pthread_cond_wait(&cond, &mutex);

    }

  • 有资源了，消费资源

  • pthread_mutex_unlock(&mutex);

示例代码：

cpp 复制代码 
#include <pthread.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
//初始化条件变量
pthread_cond_t hasTaxi = PTHREAD_COND_INITIALIZER;
//初始化互斥量
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

struct taxi{
    struct taxi *next;
    int num;
};

struct taxi *Head = NULL;
void *taxiarv(void *arg)
{
    printf("taxi arrived thread\n");
    pthread_detach(pthread_self());
    struct taxi *tx;
    int i = 1;
    while (1)
    {
        tx = malloc(sizeof(struct taxi));
        tx->num = i;
        printf("taxi %d comming\n",i);
        i++;
        pthread_mutex_lock(&lock);
        tx->next = Head;
        Head = tx;
        pthread_cond_signal(&hasTaxi);//通知消费者车来了
        pthread_mutex_unlock(&lock);
        sleep(1);
    }
    
    pthread_exit(0);
}
void *takeTaxi(void *arg)
{
    printf("take taxi thread\n");
    pthread_detach(pthread_self());
    struct taxi *tx;
    while (1)
    {
        pthread_mutex_lock(&lock);
        while (Head == NULL)//如果没有资源
        {//放置惊群效应
            pthread_cond_wait(&hasTaxi,&lock);
        }
        //有资源了，消费资源
        tx = Head;
        Head = tx->next;
        printf("Take taxi %d\n",tx->num);
        free(tx);
        pthread_mutex_unlock(&lock);
    }
    
    pthread_exit(0);
}
int main()
{
    pthread_t tid1,tid2;
    pthread_create(&tid1,NULL,taxiarv,NULL);
    pthread_create(&tid2,NULL,takeTaxi,NULL);
    while (1)
    {
        sleep(1);
    } 
}

运行结果:

注意：

  1. pthread_cond_wait(&cond, &mutex)，在没有资源等待是是先unlock 休眠，等资源到了，再lock，所以pthread_cond_wait 和 pthread_mutex_lock 必须配对使用。

pthread_mutex_unlock

如果资源没有来sleep

如果来了

pthread_mutex_lock

  1. 如果pthread_cond_signal或者pthread_cond_broadcast 早于 pthread_cond_wait ，则有可能会丢失信号。

  2. **pthead_cond_broadcast 信号会被多个线程收到，这叫线程的惊群效应。所以需要加上判断条件while循环。**即代码中的 while (Head == NULL)//如果没有资源。

二、线程池概念和实现

**概念：**通俗的讲就是一个线程的池子，可以循环的完成任务的一组线程集合

打个比喻：比如一个公司招人做项目，招到一个人，做完项目就把这个人解雇，然后又来项目就再招人再解雇，招聘和解雇流程繁琐消耗大量时间，而线程池呢就相当于招聘到一个人不解雇，来一个项目做完等着，来第二个项目继续做，就剩去了解雇和再招聘的时间。

**必要性：**我们平时创建一个线程，完成某一个任务，等待线程的退出。但当需要创建大量的线程时，假设T1为创建线程时间，T2为线程任务执行 时间，T3为线程销毁时间，当T1+T3>T2，这时候就不划算了，使用线程池可以降低频繁创建和销毁线程所带来的开销，任务处理时间比较短的时候这个好处非常显著。

线程池的基本结构：

  1. 任务队列，存储需要处理的任务，由工作线程来处理这些任务
  2. 线程池工作线程，它是任务队列任务的消费者，等待新任务的信号

线程池的实现：

  1. 创建线程池的基本结构：
  • 任务队列链表：typedef struct Task;
  • 线程池结构体：typedef struct ThreadPool;
  1. 线程池的初始化：
  • pool_init()
    {
    创建一个线程池结构
    实现任务队列互斥锁和条件变量的初始化
    创建n个工作线程
    }
  1. 线程池添加任务
  • pool_add_task
    {
    判断是否有空闲的工作线程
    给任务队列添加一个节点
    给工作线程发送信号newtask
    }
  1. 实现工作线程
  • workThread
    {
    while(1)
    {
    等待newtask任务信号
    从任务队列中删除节点
    执行任务
    }
    }

5.线程池的销毁

  • pool_destory
    {
    删除任务队列链表所有节点，释放空间
    删除所有的互斥锁条件变量
    删除线程池，释放空间
    }

示例代码：

cpp 复制代码 
#include <pthread.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#define POOL_NUM 10
//任务队列链表
typedef struct Task{
     void *(*func)(void *arg);//定义函数体指针
     void *arg;//定义参数
     struct Task *next;//因为任务是一个链表，所以还要定义一个指针
}Task;
//线程池结构体
typedef struct ThreadPool{
    pthread_mutex_t taskLock;//任务锁
    pthread_cond_t newTask;//有任务来了通知条件变量，即线程池
    pthread_t tid[POOL_NUM];//定义10个线程
    Task *queue_head;//拿到任务的头部
    int busywork;//表示有几个任务工作
}ThreadPool;
ThreadPool *pool;
//工作线程
void *workThread(void *arg)
{
    while (1)
    {
        pthread_mutex_lock(&pool->taskLock);
        pthread_cond_wait(&pool->newTask,&pool->taskLock);//没有任务的时候阻塞
        Task *ptask = pool->queue_head;//取出任务
        pool->queue_head = pool->queue_head->next;//指向任务队列的下一个节点
        pthread_mutex_unlock(&pool->taskLock);
        ptask->func(ptask->arg); //函数真正的运行
        pool->busywork--;
    }
    
}
void *realwork(void *arg)
{
    printf("Finish work %d\n",(int)arg);
}
//向线程池添加任务
void pool_add_task(int arg)
{
    Task *newTask;
    //访问线程池临界资源，所以要加锁
    pthread_mutex_lock(&pool->taskLock);
    while(pool->busywork>=POOL_NUM)
    {
        pthread_mutex_unlock(&pool->taskLock);
        usleep(10000);//休眠的时候要把锁释放掉
        pthread_mutex_lock(&pool->taskLock);
    }
    pthread_mutex_unlock(&pool->taskLock);

    newTask = malloc(sizeof(Task));
    newTask->func = realwork; //函数指针初始化
    newTask->arg = arg;

    pthread_mutex_lock(&pool->taskLock);
    Task *member = pool->queue_head;
    if(member == NULL)
    {
        pool->queue_head = newTask;
    }else
    {
        while (member->next!=NULL)//遍历链表，找到末尾
        {
            member = member->next;
        }
        member->next = newTask;//将newTask放在链表的尾部
        
    }
    pool->busywork++;
    pthread_cond_signal(&pool->newTask);
    
    pthread_mutex_unlock(&pool->taskLock);
}
//线程池的初始化
void pool_init()
{
    pool = malloc(sizeof(ThreadPool));//对线程池分配一个空间
    pthread_mutex_init(&pool->taskLock,NULL);//对任务进程初始化
    pthread_cond_init(&pool->newTask,NULL);//对条件变量进行初始化
    pool->queue_head = NULL;
    pool->busywork = 0; 
    for(int i = 0; i<POOL_NUM; i++)
    {
        pthread_create(&pool->tid[i],NULL,workThread,NULL);
    }
}
void pool_destory()
{
    Task *head;
    while (pool->queue_head!=NULL)
    {
        head = pool->queue_head;
        pool->queue_head = pool->queue_head->next;
        free(head);
    }
    pthread_mutex_destroy(&pool->taskLock);
    pthread_cond_destroy(&pool->newTask);
    free(pool);
}
int main()
{
    pool_init();
    sleep(1);
    for(int i=1;i<=20;i++)
    {
        pool_add_task(i);
    }
    sleep(5);
    pool_destory();
}

运行结果：

执行20个任务，而线程池的容量是10，所以会有10个在等待着执行。

三、线程的GDB调试

示例代码：

cpp 复制代码 
#include <pthread.h>
#include <stdio.h>

void *testThread(void *arg)
{
    char *threadName = (char *)arg;
    printf("Current running %s\n",threadName);

    printf("aaaaaa\n");
    printf("bbbbbb\n");
    pthread_exit(0);
}
int main()
{
    pthread_t tid1,tid2;

    pthread_create(&tid1,NULL,testThread,"thread1");
    pthread_create(&tid2,NULL,testThread,"thread2");

    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
}

正常运行结果：

显示线程：info thread

切换线程：thread id

将断点打在第6行

GDB设置线程锁：

------set scheduler-locking on/off

GDB为特定线程设置断点

------break location thread id

相关推荐
努力变厉害的小超超1 小时前
ArkTS中的组件基础、状态管理、样式处理、class语法以及界面渲染
笔记·鸿蒙
秃头佛爷1 小时前
Python学习大纲总结及注意事项
开发语言·python·学习
Lary_Rock2 小时前
RK3576 LINUX RKNN SDK 测试
linux·运维·服务器
dayouziei3 小时前
java的类加载机制的学习
java·学习
云飞云共享云桌面4 小时前
8位机械工程师如何共享一台图形工作站算力？
linux·服务器·网络
励志成为嵌入式工程师4 小时前
c语言简单编程练习9
c语言·开发语言·算法·vim
Peter_chq4 小时前
【操作系统】基于环形队列的生产消费模型
linux·c语言·开发语言·c++·后端
一坨阿亮5 小时前
Linux 使用中的问题
linux·运维
aloha_7895 小时前
从零记录搭建一个干净的mybatis环境
java·笔记·spring·spring cloud·maven·mybatis·springboot
hikktn6 小时前
如何在 Rust 中实现内存安全：与 C/C++ 的对比分析
c语言·安全·rust
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10红米手机使用google play