Linux编程--条件变量和线程池

目录

条件变量概念

条件变量应用场景

条件变量使用步骤

条件变量举例

线程池概念

线程池的举例

---

条件变量概念

条件变量（Condition Variable）是多线程编程中用于同步线程之间的机制。它通常与互斥锁（Mutex）配合使用，用于在等待某个条件成立时，使线程进入睡眠状态，并在条件成立后唤醒线程。条件变量提供了一种线程之间的通信机制，可以让一个线程等待其他线程满足某个条件后再继续执行，从而避免了忙等（busy-wait）的情况。在使用条件变量时，通常会先用互斥锁锁住共享资源，然后在条件变量上等待条件成立。一旦条件成立，需要通知其他线程，使它们从条件变量上的等待中醒来，这时候需要唤醒其中一个或多个线程。

条件变量应用场景

生产者消费者问题，是线程同步的一种手段。

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

int pthread_cond_wait(pthread_cond_t *restrict cond,

           pthread_mutex_t *restrict mutex);

int pthread_cond_timedwait(pthread_cond_t *restrict cond,

           pthread_mutex_t *restrict mutex,

           const struct timespec *restrict abstime);

int pthread_cond_signal(pthread_cond_t *cond);

int pthread_cond_broadcast(pthread_cond_t *cond);

条件变量使用步骤

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 he pthread_mutex_lock 必须配对使用。

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

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

条件变量举例

#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",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());
    struct 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,tid3;
 
    pthread_create(&tid1,NULL,taxiarv,NULL);
//    sleep(5);
    pthread_create(&tid2,NULL,takeTaxi,(void*)1);
    pthread_create(&tid2,NULL,takeTaxi,(void*)2);
    pthread_create(&tid2,NULL,takeTaxi,(void*)3);
 
    while(1) {
        sleep(1);
 
    }
 
 
}

线程池概念

线程池是一种预先创建的线程集合，用于执行任务和处理请求，通常会限制线程的数量以避免过度消耗系统资源。线程池技术被广泛应用于高并发的服务器端应用中，每一个请求可以被一个线程处理，线程可以被多个请求复用，从而提高了系统的性能和资源利用率。通过线程池技术可以控制线程的数量，避免创建和销毁线程的开销，以及避免因线程数目过多造成的系统性能下降的问题。

线程池的基本结构：

1 任务队列，存储需要处理的任务，由工作线程来处理这些任务

2 线程池工作线程，它是任务队列任务的消费者，等待新任务的信号

任务是无限的线程是有限的没有线程了任务就要在队列中等待。

线程池的实现：
1创建线程池的基本结构：

任务队列链表

typedef struct Task;

线程池结构体

typedef struct ThreadPool;

线程池的初始化：
pool_init()

{

创建一个线程池结构

实现任务队列互斥锁和条件变量的初始化

创建n个工作线程

}

线程池添加任务
   pool_add_task

{

    判断是否有空闲的工作线程

给任务队列添加一个节点

    给工作线程发送信号newtask

}

实现工作线程
   workThread

{

while(1){

   等待newtask任务信号

   从任务队列中删除节点

   执行任务

}

}

线程池的销毁
   pool_destory

{

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

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

删除线程池，释放空间

}

线程池的举例

#include <pthread.h>
#include <stdio.h>
#include <unistd.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];
    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;
 
    }
    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(20);
   for(int i=1;i<=20;i++){
       pool_add_task(i);
 
   }
 
   sleep(5);
   pool_destory();
 
}