day5--条件变量&&线程池

条件变量

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

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

使用步骤：

1.初始化：

静态初始化

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

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

动态初始化互斥量：pthread_cond_init(&cond);

2.生产资源线程：

pthread_mutex_lock(&mutex);

开始产生资源

pthread_cond_sigal(&cond);    //通知一个消费线程  或   pthread_cond_broadcast(&cond); //广播通知多个消费线程

pthread_mutex_unlock(&mutex);

3.消费者线程：

pthread_mutex_lock(&mutex);

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

pthread_cond_wait(&cond, &mutex);//第一个参数是初始化的条件变量，第二个参数是初始化的互斥量

}

有资源了，消费资源

pthread_mutex_unlock(&mutex);  

操作结束！

注：

1.pthread_cond_wait(&cond, &mutex)；在没有资源等待是是先unlock 休眠，等资源到了，再lock

                                                                所以pthread_cond_wait 和 pthread_mutex_lock 必须配对使用

        wait上面有个pthread_mutex_lock

        wait函数的内部操作{

        进入pthread_cond_wait后，先pthread_mutex_unlock，

        如果此时没有资源，就sleep

        如果有资源，就pthread_mutex_lock

        操作完成，退出pthread_cond_wait

        }

        wait下面有个pthread_mutex_unlock与上面的对应

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

3.pthead_cond_broadcast 信号会被多个线程收到，这叫线程的惊群效应，所以使用时需要加上判断条件while循环

coding：

//生产者与消费者之间的问题，此例为出租车与乘客问题
#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;	//初始化互斥量


typedef struct node{
	struct node* next;
	int num;

}taxi;

taxi* Head=NULL;

void *taxiCar(void *arg){	//生产线程
	printf("taxi arrived thread\n");
	pthread_detach(pthread_self());    //回收线程
	taxi *tx;
	int i=1;
	while(1){
		tx = malloc(sizeof(taxi));
		tx->num = i++;
		printf("taxi %d comming\n",tx->num);
		pthread_mutex_lock(&lock);

		tx->next = Head;
		Head = tx;

		pthread_cond_signal(&hasTaxi);    //通知单个消费线程
		//pthread_cond_broadcast(&hasTaxi);//广播通知多个消费线程

		pthread_mutex_unlock(&lock);
		sleep(1);
	}
	pthread_exit(0);
}

void* takeTaxi(void *arg){	//消费线程
	printf("take taxi thread\n");
	pthread_detach(pthread_self());
	taxi* tx;
	while(1){
		pthread_mutex_lock(&lock);
		while(Head==NULL)
		{
			pthread_cond_wait(&hasTaxi,&lock);//没有可消费资源时，等待资源
		}

		tx = Head;
		Head=tx->next;
		printf("%d,Take taxi %d\n",(int)arg,tx->num);
		free(tx);
		pthread_mutex_unlock(&lock);
	}
	pthread_exit(0);
}

int main(){
	pthread_t tid1,tid2;

	pthread_create(&tid1,NULL,taxiCar,NULL);//生产线程
	pthread_create(&tid2,NULL,takeTaxi,(void*)1);//消费线程1
	pthread_create(&tid2,NULL,takeTaxi,(void*)2);//消费线程2
	pthread_create(&tid2,NULL,takeTaxi,(void*)3);//消费线程3

	while(1) {
		sleep(1);
	}
}

线程池概念和使用

概念：

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

必要性：

我们平时创建一个线程，完成某一个任务，等待线程的退出。但当需要创建大量的线程时，假设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任务信号

   从任务队列中删除节点

   执行任务

}

}

1. 线程池的销毁

   pool_destory

{

删除任务队列链表所有节点，释放空间

删除所有的互斥锁条件变量

删除线程池，释放空间

}

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>

#define POOL_SIZE 10				//线程池大小

//任务队列结构体
typedef struct Task{
	void* (*fun)(void* arg);	//任务函数
	void* arg;					//任务参数
	struct Task* next;			//队列指针
}Task;

//线程池结构体
typedef struct PoolThread{
	pthread_mutex_t TaskLock;	//互斥锁
	pthread_cond_t NewTask;		//条件变量
	pthread_t tid[POOL_SIZE];	//线程tid号的多少
	Task* Queue_Head;			//任务队列的头
	int busy;					//线程是否忙
}PoolThread;


PoolThread* pool;

//操作执行工作的线程
void* workThread(void* arg){
	while(1){
		pthread_mutex_lock(&pool->TaskLock);
		pthread_cond_wait(&pool->NewTask,&pool->TaskLock);//没有资源就等待
		Task* temp = pool->Queue_Head;//取头任务
		pool->Queue_Head = pool->Queue_Head->next;//任务队列指针指向下一任务
		pthread_mutex_unlock(&pool->TaskLock);
		temp->fun(temp->arg);
		pool->busy--;
	}
}
//线程池初始化
void pool_init(){
	pool=malloc(sizeof(PoolThread));
	pthread_mutex_init(&pool->TaskLock,NULL);//动态初始化互斥锁
	pthread_cond_init(&pool->NewTask,NULL);//动态初始化条件变量
	pool->Queue_Head = NULL;
	pool->busy = 0;
	
	int i;
	for(i = 0;i<POOL_SIZE;i++)
		pthread_create(&pool->tid[i],NULL,workThread,NULL);
}

//真正工作的线程
void* RealWork(void* arg){
	printf("Finish %d work\n",(int)arg);
}

//向线程池和任务对列中添加任务
void pool_add_task(int arg){
	Task* new_task;
	pthread_mutex_lock(&pool->TaskLock);//访问线程池的变量时都要提前上锁
	while(pool->busy>=POOL_SIZE){
		pthread_mutex_unlock(&pool->TaskLock);
		usleep(10000);
		pthread_mutex_lock(&pool->TaskLock);
	}
	pthread_mutex_unlock(&pool->TaskLock);

	new_task=malloc(sizeof(Task));
	new_task->fun=RealWork;
	new_task->arg=arg;
	
	pthread_mutex_lock(&pool->TaskLock);
	Task* Queue_task_sum=pool->Queue_Head;
	if(Queue_task_sum==NULL){
		pool->Queue_Head=new_task;
	}
	else{
		while(Queue_task_sum->next!=NULL){
			Queue_task_sum=Queue_task_sum->next;
		}
		Queue_task_sum->next=new_task;
	}
	pool->busy++;
	pthread_cond_signal(&pool->NewTask);
	pthread_mutex_unlock(&pool->TaskLock);
}

//任务队列和线程池的销毁
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(int argc, const char *argv[])
{
	int i;
	pool_init();
	sleep(1);
	for(i=1;i<=20;i++)
		pool_add_task(i);
	sleep(2);
	pool_destory();
	return 0;
}

线程的GDB调试：

显示线程

info thread

切换线程

thread id

GDB为特定线程设置断点

break location thread id

GDB设置线程锁，

set scheduler-locking on/off

on：其他线程会暂停。可以单独调试一个线程