linux 线程池 （C语言实现）

最新推荐文章于 2024-04-11 22:49:02 发布
最新推荐文章于 2024-04-11 22:49:02 发布
阅读量1.3k 收藏 14
点赞数 3
文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44771537/article/details/123859877
版权

线程池分为三个部分：

  1. 任务队列
  2. 工作线程，N个（任务队列的消费者）
  3. 管理者线程，1个

主要实现的函数：

  1. 创建线程池
  2. 线程池添加任务
  3. 销毁线程池
  4. 任务函数（做什么）
  5. 工作线程函数
  6. 管理者线程函数

线程池结构体：

typedef struct ThreadPool
{
    Task* taskQ;    //任务队列
    int queueCapacity;  //容量
    int queueSize;      //当前任务个数
    int queueFront;     //队头 -> 取数据
    int queueRear;      //队尾 -> 放数据

    pthread_t managerID;     //管理者线程ID
    pthread_t* threadIDs;    //工作的线程ID 
    int minNum;              //最小线程数
    int maxNum;              //最小线程数
    int busyNum;             //忙的线程个数
    int liveNum;             //存活的线程个数
    int exitNum;             //要销毁的线程个数
    pthread_mutex_t mutexPool;  //互斥锁pthread_mutex_t,锁整个线程池
    pthread_mutex_t mutexBusy;  //锁busyNum变量
    pthread_cond_t notFull;     // pthread _ cond _t表示多线程的条件变量,任务队列是不是满了
    pthread_cond_t notEmpty;    //任务队列是不是空了

    int shutdown;               //是不是要销毁线程池，销毁为1，不销毁为0
};

 创建线程池函数：

ThreadPool* ThreadPoolCreate(int min, int max, int queueSize)
{
	ThreadPool* pool = (ThreadPool*)malloc(sizeof(ThreadPool));
	do
	{
		if (pool == NULL)
		{
			printf("malloc threadpool fail...\n");
			break;
		}
		//开辟工作线程空间
		pool->threadIDs = (pthread_t*)malloc(sizeof(pthread_t) * max);
		if (pool->threadIDs == NULL)
		{
			printf("malloc threadIDs fail...\n");
			break;
		}
		memset(pool->threadIDs, 0, sizeof(pthread_t) * max);
		pool->minNum = min;
		pool->maxNum = max;
		pool->busyNum = 0;
		pool->liveNum = min;
		pool->exitNum = 0;

		//互斥锁、条件变量的初始化
		if (pthread_mutex_init(&pool->mutexPool, NULL) != 0 ||
			pthread_mutex_init(&pool->mutexBusy, NULL) != 0 ||
			pthread_cond_init(&pool->notFull, NULL) != 0 ||
			pthread_cond_init(&pool->notEmpty, NULL) != 0)
		{
			printf("mutex or cond init fail...\n");
			break;
		}

		//任务队列
		pool->taskQ = (Task*)malloc(sizeof(Task) * queueSize);
		pool->queueCapacity = queueSize;
		pool->queueSize = 0;
		pool->queueFront = 0;
		pool->queueRear = 0;

		pool->shutdown = 0;

		//创建管理者线程
		pthread_create(&pool->managerID, NULL, manager, pool);
		//创建工作线程
		for (int i = 0; i < min; i++)
		{
			pthread_create(&pool->threadIDs[i], NULL, workers, pool);
		}
		return pool;
	} while (0);

	//释放资源
	if (pool && pool->threadIDs)
	{
		free(pool->threadIDs);
	}
	if (pool && pool->taskQ)
	{
		free(pool->taskQ);
	}
	if (pool)
	{
		free(pool);
	}
	return NULL;
}

工作线程函数：

void* workers(void* arg)
{
	ThreadPool* pool = (ThreadPool*)arg;
	while (1)
	{
		pthread_mutex_lock(&pool->mutexPool);

		//判断任务队列是否为空
		while (pool->queueSize == 0 && !pool->shutdown)
		{
			//阻塞线程
			pthread_cond_wait(&pool->notEmpty, &pool->mutexPool);

			//判断是不是要销毁线程
			if (pool->exitNum > 0)
			{
				pool->exitNum--;
				if (pool->liveNum > pool->minNum)
				{
					pool->liveNum--;
					pthread_mutex_unlock(&pool->mutexPool);
					threadExit(pool);
				}

			}
		}

		//判断线程池是否要关闭
		if (pool->shutdown)
		{
			pthread_mutex_unlock(&pool->mutexPool);
			threadExit(pool);
		}

		/*从任务列队中取出一个任务*/
		Task task;
		task.function = pool->taskQ[pool->queueFront].function;
		task.arg = pool->taskQ[pool->queueFront].arg;
		//每取出一个任务后需要移动任务队列的队头:（头指针+1）整除 队列大小 
		pool->queueFront = (pool->queueFront + 1) % pool->queueCapacity;
		pool->queueSize--;

		/*生产者生产了产品之后唤醒消费者，消费者消耗了产品之后唤醒生产者*/
		//消费了一个任务，需要唤醒生产者线程
		//pthread_cond_signal详解: https://blog.csdn.net/fanyun_01/article/details/106975364
		pthread_cond_signal(&pool->notFull);//消费了任务通知生产者
		pthread_mutex_unlock(&pool->mutexPool);

		
		printf("thread % ld start working...\n", pthread_self());
		pthread_mutex_lock(&pool->mutexBusy);
		pool->busyNum++;
		pthread_mutex_unlock(&pool->mutexBusy);
        //开始任务
		task.function(task.arg);
		free(task.arg);
		task.arg = NULL;

		//结束任务
		printf("thread % ld end working...\n", pthread_self());
		pthread_mutex_lock(&pool->mutexBusy);
		pool->busyNum--;
		pthread_mutex_unlock(&pool->mutexBusy);
	}
	return NULL;
}

管理者线程函数：

void* manager(void* arg)
{
	ThreadPool* pool = (ThreadPool**)arg;
	while (!pool->shutdown)
	{
		//每3秒检查一次
		sleep(3);

		//取出线程池中当前的任务数和活着的线程数(线程数是共享资源，操作里面的数据需要加锁)
		pthread_mutex_lock(&pool->mutexPool);
		int queueSize = pool->queueSize;
		int liveNum = pool->liveNum;
		pthread_mutex_unlock(&pool->mutexPool);


		//取出忙的线程数
		pthread_mutex_lock(&pool->mutexBusy);
		int busyNum = pool->busyNum;
		pthread_mutex_unlock(&pool->mutexBusy);

		//添加线程：
		//1.定义添加线程时机的规则: 任务个数>存活的线程个数 && 存活的线程个数<最大线程数
		if (queueSize > liveNum && liveNum < pool->maxNum)
		{
			int counter = 0;
			//切记加锁
			pthread_mutex_lock(&pool->mutexPool);
			for (int i = 0; i < pool->maxNum && counter < NUMBER && liveNum < pool->maxNum; ++i)
			{
				if (pool->threadIDs[i] == 0)
				{
					pthread_create(&pool->threadIDs[i], NULL, workers, pool);
					counter++;
					pool->liveNum++;

				}
			}
			pthread_mutex_unlock(&pool->mutexPool);
		}

		//销毁线程
		//1.定义销毁线程时机的规则: 忙的个数*2<存活的线程个数 && 存活的线程个数>最小线程数
		if (busyNum * 2 < liveNum && liveNum > pool->minNum)
		{
			//切记加锁
			pthread_mutex_lock(&pool->mutexPool);
			pool->exitNum = NUMBER;
			pthread_mutex_unlock(&pool->mutexPool);
			for (int i = 0; i < NUMBER; i++)
			{
				//这里只能让工作的线程自杀，不能主动销毁工作线程
				//使阻塞的线程脱离阻塞状态（pool->notEmpty）
				pthread_cond_signal(&pool->notEmpty);
			}
		}
	}
	return NULL;
}

线程池任务添加函数：

void threadPoolAdd(ThreadPool* pool, void(*func)(void*), void* arg)
{
	pthread_mutex_lock(&pool->mutexPool);
	while (pool->queueSize == pool->queueCapacity && !pool->shutdown)
	{
		//阻塞管理者（生产者）线程
		pthread_cond_wait(&pool->notFull, &pool->mutexPool);
	}
	if (pool->shutdown)
	{
		pthread_mutex_unlock(&pool->mutexPool);
		return;
	}

	//添加任务
	pool->taskQ[pool->queueRear].function = func;//
	pool->taskQ[pool->queueRear].arg = arg;
	pool->queueRear = (pool->queueRear + 1) % pool->queueCapacity;
	pool->queueSize++;
	pthread_cond_signal(&pool->notEmpty);//有新任务通知消费者
	pthread_mutex_unlock(&pool->mutexPool);

}

具体实现：

main.c:

#include <stdio.h>
#include"threadpool.h"
#include<pthread.h>
#include<stdlib.h>
#include <unistd.h>
/*
* <cstdio> (stdio.h)

C库执行输入/输出操作：

输入和输出操作也可以在C++实现，通过使用C标准输入和输出库（cstdio，在C语言中称为stdio.h）。

这个库使用流来操作物理设备如键盘，打印机，终端或者系统支持的任何其他类型的文件。
*/

void taskFunc(void* arg)
{
    int num = *(int*)arg;
    printf("thread %ld is working ,number=%d\n", pthread_self(), num);
    sleep(1);
}


int main()
{
    //创建线程池
    ThreadPool* pool = ThreadPoolCreate(3, 10, 100);

    for (int i = 0; i < 100; i++)
    {
        int* num = (int*)malloc(sizeof(int));
        *num = i + 100;
        threadPoolAdd(pool,taskFunc,num);
    }
    sleep(30);
    ThreadPoolDestroy(pool);
    return 0;
}

threadpool.h:

#ifndef _THREADPOOL_H //如果不存在threadpool.h
#define _THREADPOOL_H //就引入threadpool.h

typedef struct ThreadPool ThreadPool;

//创建线程池并初始化
ThreadPool *ThreadPoolCreate(int min, int max, int queueSize);


//销毁线程池
int ThreadPoolDestroy(ThreadPool* pool);


//给线程池添加任务
void threadPoolAdd(ThreadPool* pool, void(*func)(void*), void* arg);

//获取线程池中工作的个数
int threadPoolBusyNum(ThreadPool* pool);

//获取线程池中活着的个数
int threadPoolAliveNum(ThreadPool* pool);

//工作（消费者）任务函数
void* workers(void* arg);

//管理线程任务函数
void* manager(void* arg);

//单个线程退出

 //否则不需要引入

#endif

threadpool.c:

#include"threadpool.h"
#include<pthread.h>
#include<stdlib.h>
#include<stdio.h>
#include<string.h>
#include<unistd.h>

const int NUMBER = 2;
//任务结构体
typedef struct Task
{
	void(*function)(void* arg); // 函数指针,任务函数
	void* arg;                  //万能指针，任务函数参数
} Task;

//线程池结构体
typedef struct ThreadPool
{
	Task* taskQ;    //任务队列
	int queueCapacity;  //容量
	int queueSize;      //当前任务个数
	int queueFront;     //队头 -> 取数据
	int queueRear;      //队尾 -> 放数据

	pthread_t managerID;     //管理者线程ID
	pthread_t* threadIDs;    //工作的线程ID 
	int minNum;              //最小线程数
	int maxNum;              //最小线程数
	int busyNum;             //忙的线程个数
	int liveNum;             //存活的线程个数
	int exitNum;             //要销毁的线程个数
	pthread_mutex_t mutexPool;  //互斥锁pthread_mutex_t,锁整个线程池
	pthread_mutex_t mutexBusy;  //锁busyNum变量
	pthread_cond_t notFull;     // pthread _ cond _t表示多线程的条件变量,任务队列是不是满了
	pthread_cond_t notEmpty;    //任务队列是不是空了

	int shutdown;               //是不是要销毁线程池，销毁为1，不销毁为0
};

ThreadPool* ThreadPoolCreate(int min, int max, int queueSize)
{
	ThreadPool* pool = (ThreadPool*)malloc(sizeof(ThreadPool));
	do
	{
		if (pool == NULL)
		{
			printf("malloc threadpool fail...\n");
			break;
		}
		//开辟工作线程空间
		pool->threadIDs = (pthread_t*)malloc(sizeof(pthread_t) * max);
		if (pool->threadIDs == NULL)
		{
			printf("malloc threadIDs fail...\n");
			break;
		}
		memset(pool->threadIDs, 0, sizeof(pthread_t) * max);
		pool->minNum = min;
		pool->maxNum = max;
		pool->busyNum = 0;
		pool->liveNum = min;
		pool->exitNum = 0;

		//互斥锁、条件变量的初始化
		if (pthread_mutex_init(&pool->mutexPool, NULL) != 0 ||
			pthread_mutex_init(&pool->mutexBusy, NULL) != 0 ||
			pthread_cond_init(&pool->notFull, NULL) != 0 ||
			pthread_cond_init(&pool->notEmpty, NULL) != 0)
		{
			printf("mutex or cond init fail...\n");
			break;
		}

		//任务队列
		pool->taskQ = (Task*)malloc(sizeof(Task) * queueSize);
		pool->queueCapacity = queueSize;
		pool->queueSize = 0;
		pool->queueFront = 0;
		pool->queueRear = 0;

		pool->shutdown = 0;

		//创建管理者线程
		pthread_create(&pool->managerID, NULL, manager, pool);
		//创建工作线程
		for (int i = 0; i < min; i++)
		{
			pthread_create(&pool->threadIDs[i], NULL, workers, pool);
		}
		return pool;
	} while (0);

	//释放资源
	if (pool && pool->threadIDs)
	{
		free(pool->threadIDs);
	}
	if (pool && pool->taskQ)
	{
		free(pool->taskQ);
	}
	if (pool)
	{
		free(pool);
	}
	return NULL;
}


void threadPoolAdd(ThreadPool* pool, void(*func)(void*), void* arg)
{
	pthread_mutex_lock(&pool->mutexPool);
	while (pool->queueSize == pool->queueCapacity && !pool->shutdown)
	{
		//阻塞管理者（生产者）线程
		pthread_cond_wait(&pool->notFull, &pool->mutexPool);
	}
	if (pool->shutdown)
	{
		pthread_mutex_unlock(&pool->mutexPool);
		return;
	}

	//添加任务
	pool->taskQ[pool->queueRear].function = func;//
	pool->taskQ[pool->queueRear].arg = arg;
	pool->queueRear = (pool->queueRear + 1) % pool->queueCapacity;
	pool->queueSize++;
	pthread_cond_signal(&pool->notEmpty);//有新任务通知消费者
	pthread_mutex_unlock(&pool->mutexPool);

}

/*管理者线程主要负责创建线程和销毁线程*/
void* manager(void* arg)
{
	ThreadPool* pool = (ThreadPool**)arg;
	while (!pool->shutdown)
	{
		//每3秒检查一次
		sleep(3);

		//取出线程池中当前的任务数和活着的线程数(线程数是共享资源，操作里面的数据需要加锁)
		pthread_mutex_lock(&pool->mutexPool);
		int queueSize = pool->queueSize;
		int liveNum = pool->liveNum;
		pthread_mutex_unlock(&pool->mutexPool);


		//取出忙的线程数
		pthread_mutex_lock(&pool->mutexBusy);
		int busyNum = pool->busyNum;
		pthread_mutex_unlock(&pool->mutexBusy);

		//添加线程：
		//1.定义添加线程时机的规则: 任务个数>存活的线程个数 && 存活的线程个数<最大线程数
		if (queueSize > liveNum && liveNum < pool->maxNum)
		{
			int counter = 0;
			//切记加锁
			pthread_mutex_lock(&pool->mutexPool);
			for (int i = 0; i < pool->maxNum && counter < NUMBER && liveNum < pool->maxNum; ++i)
			{
				if (pool->threadIDs[i] == 0)
				{
					pthread_create(&pool->threadIDs[i], NULL, workers, pool);
					counter++;
					pool->liveNum++;

				}
			}
			pthread_mutex_unlock(&pool->mutexPool);
		}

		//销毁线程
		//1.定义销毁线程时机的规则: 忙的个数*2<存活的线程个数 && 存活的线程个数>最小线程数
		if (busyNum * 2 < liveNum && liveNum > pool->minNum)
		{
			//切记加锁
			pthread_mutex_lock(&pool->mutexPool);
			pool->exitNum = NUMBER;
			pthread_mutex_unlock(&pool->mutexPool);
			for (int i = 0; i < NUMBER; i++)
			{
				//这里只能让工作的线程自杀，不能主动销毁工作线程
				//使阻塞的线程脱离阻塞状态（pool->notEmpty）
				pthread_cond_signal(&pool->notEmpty);
			}
		}
	}
	return NULL;
}

void* workers(void* arg)
{
	ThreadPool* pool = (ThreadPool*)arg;
	while (1)
	{
		pthread_mutex_lock(&pool->mutexPool);

		//判断任务队列是否为空
		while (pool->queueSize == 0 && !pool->shutdown)
		{
			//阻塞线程
			pthread_cond_wait(&pool->notEmpty, &pool->mutexPool);

			//判断是不是要销毁线程
			if (pool->exitNum > 0)
			{
				pool->exitNum--;
				if (pool->liveNum > pool->minNum)
				{
					pool->liveNum--;
					pthread_mutex_unlock(&pool->mutexPool);
					threadExit(pool);
				}

			}
		}

		//判断线程池是否要关闭
		if (pool->shutdown)
		{
			pthread_mutex_unlock(&pool->mutexPool);
			threadExit(pool);
		}

		/*从任务列队中取出一个任务*/
		Task task;
		task.function = pool->taskQ[pool->queueFront].function;
		task.arg = pool->taskQ[pool->queueFront].arg;
		//每取出一个任务后需要移动任务队列的队头:（头指针+1）整除 队列大小 
		pool->queueFront = (pool->queueFront + 1) % pool->queueCapacity;
		pool->queueSize--;

		/*生产者生产了产品之后唤醒消费者，消费者消耗了产品之后唤醒生产者*/
		//消费了一个任务，需要唤醒生产者线程
		//pthread_cond_signal详解: https://blog.csdn.net/fanyun_01/article/details/106975364
		pthread_cond_signal(&pool->notFull);//消费了任务通知生产者
		pthread_mutex_unlock(&pool->mutexPool);

		//开始任务
		printf("thread % ld start working...\n", pthread_self());
		pthread_mutex_lock(&pool->mutexBusy);
		pool->busyNum++;
		pthread_mutex_unlock(&pool->mutexBusy);
		task.function(task.arg);
		free(task.arg);
		task.arg = NULL;

		//结束任务
		printf("thread % ld end working...\n", pthread_self());
		pthread_mutex_lock(&pool->mutexBusy);
		pool->busyNum--;
		pthread_mutex_unlock(&pool->mutexBusy);
	}
	return NULL;
}

void threadExit(ThreadPool* pool)
{
	//pthread_self(): https://blog.csdn.net/weixin_43778179/article/details/115219071
	pthread_t tid = pthread_self();
	for (int i = 0; i < pool->maxNum; i++)
	{
		if (pool->threadIDs[i] == tid)
		{
			pool->threadIDs[i] = 0;
			printf("threadExit() called,%ld exiting...\n", tid);
			break;
		}
	}
	pthread_exit(NULL);
}

int threadPoolBusyNum(ThreadPool* pool)
{
	pthread_mutex_lock(&pool->mutexPool);
	int busyNum = pool->busyNum;
	pthread_mutex_unlock(&pool->mutexPool);
	return busyNum;
}

int threadPoolAliveNum(ThreadPool* pool)
{
	pthread_mutex_lock(&pool->mutexPool);
	int aliveNum = pool->liveNum;
	pthread_mutex_unlock(&pool->mutexPool);
	return aliveNum;
}

int ThreadPoolDestroy(ThreadPool* pool)
{
	if (pool==NULL)
	{
		return -1;
	}
	//关闭线程池
	pool->shutdown = 1;
	//阻塞生产者
	pthread_join(pool->managerID, NULL);

	//唤醒阻塞的线程，被唤醒的线程会自动死亡，详情参照205行代码
	for (int i = 0; i < pool->liveNum; i++)
	{
		pthread_cond_signal(&pool->notEmpty);
	}
	//释放堆内存
	if (pool->taskQ)
	{
		free(pool->taskQ);
	}
	if (pool->threadIDs)
	{
		free(pool->threadIDs);
	}


	pthread_mutex_destroy(&pool->mutexBusy);
	pthread_mutex_destroy(&pool->mutexPool);
	pthread_cond_destroy(&pool->notEmpty);
	pthread_cond_destroy(&pool->notFull);
	free(pool);
	pool = NULL;
	return 0;
}

好吧好吧好好努力吧
关注
  • 3
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Linux下C线程池实现
05-05
在Linux下用C写的一个简易线程池。系统是RedHat 9，gcc版本"gcc version 4.1.2 20071124 (Red Hat 4.1.2-42)"。文件夹里的源码是按工程组织好的，在文件夹下的test目录下面有一个小的测试程序和Makefile，编译后即可运行。测试过添加了300多个任务，同时并发256个线程，运行正常。不过在停止线程(包括系统空闲时减少线程数量)方面还没完全实现好，需要用的话可以自己添加或者暂时先不管这方面。 补充：利用7号中午的时间已经把上述的问题解决了，现已能正确的根据当前任务数动态减少线程。不过现在不方便也不想上传了，需要的话可以通过源文件中的邮箱联系我或在以后去google code下载。如果各位有好的建议，欢迎通过邮件联系。 -------- by vincent
linux线程池，c语言实现
01-06
以上就是关于“Linux线程池，C语言实现”的主要技术要点。实际的代码实现会涉及到这些概念的具体应用和细节处理。在开发过程中，要充分考虑线程池的扩展性、可靠性和效率，以满足不同应用场景的需求。
[Linux程序设计] C语言实现线程池
weixin_62337145的博客
07-11 892
在linux环境下使用C语言完成线程池的创建。在程序中多次创建线程会占用CPU时间，如何保证一个线程可以复用，提高CPU的利用率，线程池可以解决这些问题。
linux下c语言版线程池
进击的菜鸟
03-30 3035
1. 线程池原理 我们使用线程的时候就去创建一个线程，这样实现起来非常简便，但是就会有一个问题：如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。 那么有没有一种办法使得线程可以复用，就是执行完一个任务，并不被销毁，而是可以继续执行其他的任务呢？ 线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的堆栈大小，以默认的优先..
Linux下使用C语言实现线程池---代码及分析
最新发布
qq_61585528的博客
04-11 348
Linux下使用C语言实现线程池
Linux: C实现动态线程池。
qq_51004011的博客
11-16 539
所谓的池概念：都是事先创建好一些事物的集合，在需要使用时，直接调用即可。而不是在需要时才去创建。这里所讲的线程池，其实就是若干个线程的集合，形成的线程池。
linux C 线程池
zhuguanlin121的博客
12-29 688
linux C 线程池
linux下C语言实现线程池
12-25
接下来，我们将深入探讨如何在Linux环境下用C语言实现线程池。 首先，我们需要了解线程的基本概念。在C语言中，线程是进程内的一个执行单元，每个线程都有自己的程序计数器、栈和局部变量，但共享全局变量和其他...
线程池Linux C语言简单版本
08-02
本线程池采用C语言实现。包括以下内容 > - thread_pool_create：创建线程池所需要的资源，包含不限于任务队列，子线程的创建。 > - thread_pool_post：用于任务的发布，将执行任务存在任务队列中。 > - thread_pool_...
线程池 threadPool c语言实现
12-05
总的来说，C语言实现的线程池通过合理管理和调度线程，可以提高系统性能，降低资源消耗。对于需要处理大量并发请求的服务器应用或者计算密集型任务，线程池是不可或缺的优化手段。在深入理解线程池的工作原理后，...
linux线程池的C语言实现
02-27
通常我们使用多线程的方式是，需要时创建一个新的线程，在这个新的线程里执行特定的任务，然后在任务完成后退出。这在一般的应用里已经能够满足我们应用的需要，毕竟我们并不是什么时候都需要创建大量的线程，并在...
Linux组件之线程池
Ricardo2的博客
06-29 727
手写线程池
linux C实现线程池
wwxy1995的博客
08-20 234
线程池包括任务队列，线程数组，管理模块几个部分，依次实现这几个模块 typedef struct tk_task{ void (*func)(void*); void* arg; struct tk_task* next; // 任务链表（下一节点指针） }tk_task_t; 任务队列，用单链表的方式实现 线程池的管理模块用以下 typedef stru...
linux C 简单线程池实现
快乐小半半的博客
08-11 436
线程过多会带来额外的开销，其中包括创建销毁线程的开销、调度线程的开销等等，同时也降低了计算机的整体性能。线程池维护多个线程，等待监督管理者分配可并发执行的任务。这种做法，一方面避免了处理任务时创建销毁线程开销的代价，另一方面避免了线程数量膨胀导致的过分调度问题，保证了对内核的充分利用。...
linux下使用C实现线程池
KiKilove7的博客
08-29 777
在高并发需求下，以往的方案（有事件发生时创建新线程处理事件，处理完后销毁线程），这种方法由于创建线程和销毁线程浪费了大量的资源。因此转换一种思路，每次程序启动后先创建一些线程，让他们等事件发生，发生后再去处理，处理后不销毁，让他等待事件发生。 今天用宇宙最强语言C语言来实现一下，先看一下线程池定义的结构体： structthreadpool_t{ pthread_mutex_tlock;/*用于锁住本结构体*/ pthread_mut...
linux下c/c++实例之十三C实现的简单的线程池
乌托邦
11-17 4766
一、简介         线程池就是有一堆已经创建好了的线程，初始它们都处于空闲等待状态，当有新的任务需要处理的时候，就从这个池子里面取一个空闲等待的线程来处理该任务，当处理完成了就再次把该线程放回池中，以供后面的任务使用。当池子里的线程全都处理忙碌状态时，线程池中没有可用的空闲等待线程，此时，根据需要选择创建一个新的线程并置入池中，或者通知任务线程池忙，稍后再试。        为什么要
非常精简的Linux线程池实现（一）——使用互斥锁和条件变量
热门推荐
kxcfzyk的专栏
06-17 1万+
其实线程池的原理非常简单，它就是一个非常典型的生产者消费者同步问题。如果不知道我说的这个XXX问题也不要紧，我下面就解释。
【Linux】400行纯C语言代码带你【手撕线程池】
呋喃吖的博客
05-22 1145
纯C语言手撕线程池！！！！
linux线程池c的实现原理,Linux-C实现线程池
weixin_42659252的博客
05-07 184
文章目录池​池是一组资源的集合，这组资源在服务器启动之初就被创建和初始化，这称为静态资源分配。它避免了服务器对内核的频繁访问，提高了效率。​常见的池有进程池，线程池，内存池内存池​先申请一定数量，大小相等的内存块备用。有新的内存需求时，就从内存池中分出一部分内存块，若内存不足则继续申请新的内存。内存池使内存分配效率得到提升进程池​进程池线先由服务器创建一组子进程，子进程数量应和CPU数量差不多。所...
linux线程池c语言实现
07-25
在C语言中实现一个简单的线程池可以按照以下步骤进行： 1. 定义线程池结构体：创建一个结构体，包含线程池中的线程数量、任务队列、互斥锁、条件变量等必要的成员。 ```c typedef struct { pthread_t *threads; /...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值