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

一、条件变量

二、线程池概念和实现

三、线程的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);

示例代码：

#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);} 
}

运行结果:

注意：

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

pthread_mutex_unlock

如果资源没有来sleep

如果来了

pthread_mutex_lock

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

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

二、线程池概念和实现

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

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

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

线程池的基本结构：

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

线程池的实现：

创建线程池的基本结构：

任务队列链表：typedef struct Task;
线程池结构体：typedef struct ThreadPool;

2. 线程池的初始化：

pool_init()
{
创建一个线程池结构
实现任务队列互斥锁和条件变量的初始化
创建n个工作线程
}

3. 线程池添加任务

pool_add_task
{
判断是否有空闲的工作线程
给任务队列添加一个节点
给工作线程发送信号newtask
}

4. 实现工作线程

workThread
{
while(1)
{
等待newtask任务信号
从任务队列中删除节点
执行任务
}
}

5.线程池的销毁

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

示例代码：

#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调试

示例代码：

#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);
}

正常运行结果：