线程池使用

最新推荐文章于 2023-01-10 23:39:06 发布
最新推荐文章于 2023-01-10 23:39:06 发布
阅读量107 收藏 1
点赞数
分类专栏： 进程间通信 C
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiadeliang1111/article/details/111934861
版权

场景：初始化时，创建好线程池，使用时，根据资源使用情况，调用多少个线程。避免了程序循环执行时，需要不停创建线程的情况。

 

上源码：

/************************************************************************
* module			: 线程池头文件
* file name		: lib_thread_pool.h
* Author 			: 
* version			: V1.0
* DATE			: 
* directory 		: 
* description		: 
* related document: 
* 
************************************************************************/
/*-----------------------includes-------------------------------*/
#ifndef __PTHREAD_POOL_H__
#define __PTHREAD_POOL_H__

#include <pthread.h>

/*---------------constants/macro definition---------------------*/
#define DEFAULT_MAX_THREAD_NUM		100
#define DEFAULT_FREE_THREAD_NUM		10	
typedef struct worker_t worker_t;
typedef struct CThread_pool_t CThread_pool_t;

/*---------------global variables definition-----------------------*/
/*线程池任务结点*/
struct worker_t
{
	void *(*process) (void *arg);	/**< 回调函数 */
    int   paratype;					/**< 函数类型(预留) */
    void *arg;						/**< 回调函数参数 */
    struct worker_t *next;			/**< 连接下一个任务结点 */
};

/*线程池控制器*/
struct CThread_pool_t
{
	pthread_mutex_t queue_lock;	/**< 互斥锁 */
    pthread_cond_t queue_ready;	/**< 条件变量 */

    worker_t *queue_head;	/**< 任务结点链表,保存所有投递的任务 */
    int shutdown;			/**< 线程池销毁标志,1 - 销毁 */
    pthread_t *threadid;	/**< 线程ID */
    int max_thread_num;		/**< 线程池可容纳的最大线程数 */
	int current_pthread_num;	/**< 当前线程池存放的线程数 */
	int current_pthread_task_num;	/**< 当前正在执行任务和已分配任务的线程数目和 */
    int cur_queue_size;		/**< 当前等待队列的任务数目 */
	int	free_pthread_num;	/**< 线程池内允许存在的最大空闲线程数 */
	
	/****************************************************************
	* function name 		: ThreadPoolAddWorkLimit
	* functional description	: 向线程池投递任务
	* input parameter		: pthis	线程池指针
						  process	回调函数
						  arg		回调函数的参数
	* output parameter	: 
	* return value			: 0 - 成功;-1 - 失败 
	* history				: 
	*****************************************************************/
	int (*AddWorkUnlimit)(void* pthis,void *(*process) (void *arg), void *arg); 

	/****************************************************************
	* function name 		: ThreadPoolAddWorkUnlimit
	* functional description	: 向线程池投递任务,无空闲线程则阻塞
	* input parameter		: pthis	线程池指针
						  process	回调函数
						  arg		回调函数的参数
	* output parameter	: 
	* return value			: 0 - 成功;-1 - 失败 
	* history				: 
	*****************************************************************/
	int (*AddWorkLimit)(void* pthis,void *(*process) (void *arg), void *arg); 
	
	/****************************************************************
	* function name 		: ThreadPoolGetThreadMaxNum
	* functional description	: 获取线程池可容纳的最大线程数
	* input parameter		: pthis	线程池指针
	* output parameter	: 
	* return value			: 线程池可容纳的最大线程数
	* history				: 
	*****************************************************************/
	int (*GetMaxThreadNum) (void *pthis); 

	/****************************************************************
	* function name 		: ThreadPoolGetCurrentThreadNum
	* functional description	: 获取线程池存放的线程数
	* input parameter		: pthis	线程池指针
	* output parameter	: 
	* return value			: 线程池存放的线程数
	* history				: 
	*****************************************************************/	
	int (*GetCurThreadNum) (void *pthis); 
	
	/****************************************************************
	* function name 		: ThreadPoolGetCurrentTaskThreadNum
	* functional description	: 获取当前正在执行任务和已分配任务的线程数目和
	* input parameter		: pthis	线程池指针
	* output parameter	: 
	* return value			: 当前正在执行任务和已分配任务的线程数目和
	* history				: 
	*****************************************************************/
	int (*GetCurTaskThreadNum) (void *pthis); 
	
	/****************************************************************
	* function name 		: ThreadPoolGetCurrentTaskNum
	* functional description	: 获取线程池等待队列任务数
	* input parameter		: pthis	线程池指针
	* output parameter	: 
	* return value			: 等待队列任务数
	* history				: 
	*****************************************************************/
	int (*GetCurTaskNum) (void *pthis); 
	
	/****************************************************************
	* function name 		: ThreadPoolDestroy
	* functional description	: 销毁线程池
	* input parameter		: pthis	线程池指针
	* output parameter	: 
	* return value			: 0 - 成功;-1 - 失败
	* history				: 
	*****************************************************************/
	int (*Destruct) (void *pthis); 
};

/*---------------functions declaration--------------------------*/
/****************************************************************
* function name 		: ThreadPoolConstruct
* functional description	: 创建线程池
* input parameter		: max_num	线程池可容纳的最大线程数
					  free_num	线程池允许存在的最大空闲线程,超过则将线程释放回操作系统
* output parameter	: 
* return value			: 线程池指针
* history				: 
*****************************************************************/
CThread_pool_t* ThreadPoolConstruct(int max_num,int free_num);

/****************************************************************
* function name 		: ThreadPoolConstructDefault
* functional description	: 创建线程池,以默认的方式初始化,未创建线程
* input parameter		: 
* output parameter	: 
* return value			: 线程池指针
* history				: 
*****************************************************************/
CThread_pool_t* ThreadPoolConstructDefault(void);

#endif


/************************************************************************
* module			: 线程池实现
* file name		: lib_thread_pool.c
* Author 			: 
* version			: V1.0
* DATE			: 
* directory 		: 
* description		: 
* related document: 
* 
************************************************************************/
/*-----------------------includes-------------------------------*/
#include <stdio.h> 
#include <stdlib.h> 
#include <unistd.h> 
#include <sys/types.h> 
#include <pthread.h> 
#include <assert.h> 
#include <string.h>
#include "lib_thread_pool.h"


/*---------------constants/macro definition---------------------*/

/*---------------global variables definition-----------------------*/

/*---------------functions declaration--------------------------*/
static void * ThreadPoolRoutine (void *arg); 

/*---------------functions definition---------------------------*/

/****************************************************************
* function name 		: ThreadPoolAddWorkLimit
* functional description	: 向线程池投递任务,无空闲线程则阻塞
* input parameter		: pthis	线程池指针
					  process	回调函数
					  arg		回调函数的参数
* output parameter	: 
* return value			: 0 - 成功;-1 - 失败 
* history				: 
*****************************************************************/
static int ThreadPoolAddWorkLimit(void* pthis,void *(*process) (void *arg), void *arg) 
{ 
	CThread_pool_t *pool = (CThread_pool_t *)pthis;
    worker_t *newworker = (worker_t *) malloc (sizeof (worker_t)); 
	if (NULL == newworker)
	{
		return -1;
	}
    newworker->process 	= process;	/**< 回调函数,在线程ThreadPoolRoutine()中执行 */
    newworker->arg 		= arg;		/**< 回调函数参数 */
    newworker->next 	= NULL;

    pthread_mutex_lock(&(pool->queue_lock)); 
	
    worker_t *member = pool->queue_head;	/**< 等待队列任务链表 */
    if (member != NULL) 
    { 
        while (member->next != NULL) 
        {
        	member = member->next; 
        }
        member->next = newworker;	/**< 放入链表尾 */
    } 
    else 
    { 
        pool->queue_head = newworker;	/**< 放入链表头 */
    } 
	
    assert (pool->queue_head != NULL); 
    pool->cur_queue_size++;		/**< 等待队列加1 */

	int FreeThreadNum = pool->current_pthread_num - pool->current_pthread_task_num;		
	//printf("FreeThreadNum:%d, pool->current_pthread_num:%d,current_pthread_task_num:%d\n", FreeThreadNum, pool->current_pthread_num, pool->current_pthread_task_num);
    if((0 == FreeThreadNum) && (pool->current_pthread_num < pool->max_thread_num))
    {
		//printf("new thread add\n");
		/**< 如果没有空闲线程且池中当前线程数不超过可容纳最大线程 */
    	int current_pthread_num = pool->current_pthread_num;
    	pool->threadid = (pthread_t *) realloc(pool->threadid,(current_pthread_num + 1) * sizeof (pthread_t));	 /**< 新增线程 */
		if (pool->threadid == NULL) return -1;
		pthread_create (&(pool->threadid[current_pthread_num]), NULL, ThreadPoolRoutine,  (void*)pool);
		pool->current_pthread_num++;	/**< 当前池中线程总数加1 */	
		
		pool->current_pthread_task_num++;	/**< 分配任务的线程数加1 */	
		pthread_mutex_unlock (&(pool->queue_lock)); 
    	pthread_cond_signal (&(pool->queue_ready));	/**< 发送信号给1个处于条件阻塞等待状态的线程 */	
		usleep(10);
		return 0;
    }

	pool->current_pthread_task_num++; 
    pthread_mutex_unlock(&(pool->queue_lock)); 
    pthread_cond_signal(&(pool->queue_ready));
	usleep(10);	//看情况加
    return 0; 
} 

/****************************************************************
* function name 		: ThreadPoolAddWorkUnlimit
* functional description	: 向线程池投递任务
* input parameter		: pthis	线程池指针
					  process	回调函数
					  arg		回调函数的参数
* output parameter	: 
* return value			: 0 - 成功;-1 - 失败 
* history				: 
*****************************************************************/
static int ThreadPoolAddWorkUnlimit(void* pthis,void *(*process) (void *arg), void *arg) 
{ 
	CThread_pool_t *pool = (CThread_pool_t *)pthis;
    worker_t *newworker = (worker_t *) malloc (sizeof (worker_t)); 
	
	if (NULL == newworker)
	{
		return -1;
	}
    newworker->process 	= process;	
    newworker->arg 		= arg; 		
    newworker->next 	= NULL;		

    pthread_mutex_lock(&(pool->queue_lock)); 
	
    worker_t *member = pool->queue_head; 
    if (member != NULL) 	
    { 
        while (member->next != NULL) 
        {
        	member = member->next; 
        }
        member->next = newworker; 
    } 
    else 
    { 
        pool->queue_head = newworker; 
    } 
	
    assert (pool->queue_head != NULL); 
    pool->cur_queue_size++; 

	int FreeThreadNum = pool->current_pthread_num - pool->current_pthread_task_num;
    if(0 == FreeThreadNum)	/**< 只判断是否没有空闲线程 */
    {
    	int current_pthread_num = pool->current_pthread_num;
    	pool->threadid = (pthread_t *) realloc(pool->threadid,(current_pthread_num + 1) * sizeof (pthread_t)); 
		pthread_create (&(pool->threadid[current_pthread_num]), NULL, ThreadPoolRoutine,  (void*)pool);
		pool->current_pthread_num++;
		if (pool->current_pthread_num > pool->max_thread_num)
		{
			pool->max_thread_num = pool->current_pthread_num;
		}
		
		pool->current_pthread_task_num++;
		pthread_mutex_unlock (&(pool->queue_lock)); 
    	pthread_cond_signal (&(pool->queue_ready)); 
		return 0;
    }
	
	pool->current_pthread_task_num++;
    pthread_mutex_unlock(&(pool->queue_lock)); 
    pthread_cond_signal(&(pool->queue_ready)); 	
//	usleep(10);	//看情况加
    return 0; 
} 

/****************************************************************
* function name 		: ThreadPoolGetThreadMaxNum
* functional description	: 获取线程池可容纳的最大线程数
* input parameter		: pthis	线程池指针
* output parameter	: 
* return value			: 线程池可容纳的最大线程数
* history				: 
*****************************************************************/
static int ThreadPoolGetThreadMaxNum(void* pthis) 
{ 
	CThread_pool_t *pool = (CThread_pool_t *)pthis;
	
    pthread_mutex_lock(&(pool->queue_lock)); 
	int num = pool->max_thread_num;
    pthread_mutex_unlock(&(pool->queue_lock)); 
	
    return num; 
} 

/****************************************************************
* function name 		: ThreadPoolGetCurrentThreadNum
* functional description	: 获取线程池存放的线程数
* input parameter		: pthis	线程池指针
* output parameter	: 
* return value			: 线程池存放的线程数
* history				: 
*****************************************************************/
static int ThreadPoolGetCurrentThreadNum(void* pthis) 
{ 
	CThread_pool_t *pool = (CThread_pool_t *)pthis;
	
    pthread_mutex_lock(&(pool->queue_lock)); 
	int num = pool->current_pthread_num;
    pthread_mutex_unlock(&(pool->queue_lock)); 
	
    return num; 
} 

/****************************************************************
* function name 		: ThreadPoolGetCurrentTaskThreadNum
* functional description	: 获取当前正在执行任务和已分配任务的线程数目和
* input parameter		: pthis	线程池指针
* output parameter	: 
* return value			: 当前正在执行任务和已分配任务的线程数目和
* history				: 
*****************************************************************/
static int ThreadPoolGetCurrentTaskThreadNum(void* pthis) 
{ 
	CThread_pool_t *pool = (CThread_pool_t *)pthis;
	
    pthread_mutex_lock(&(pool->queue_lock)); 
	int num = pool->current_pthread_task_num;
    pthread_mutex_unlock(&(pool->queue_lock)); 
	
    return num; 
} 

/****************************************************************
* function name 		: ThreadPoolGetCurrentTaskNum
* functional description	: 获取线程池等待队列任务数
* input parameter		: pthis	线程池指针
* output parameter	: 
* return value			: 等待队列任务数
* history				: 
*****************************************************************/
static int ThreadPoolGetCurrentTaskNum(void* pthis) 
{ 
	CThread_pool_t *pool = (CThread_pool_t *)pthis;
	
    pthread_mutex_lock(&(pool->queue_lock)); 
	int num = pool->cur_queue_size;
    pthread_mutex_unlock(&(pool->queue_lock)); 
	
    return num; 
} 

/****************************************************************
* function name 		: ThreadPoolDestroy
* functional description	: 销毁线程池
* input parameter		: pthis	线程池指针
* output parameter	: 
* return value			: 0 - 成功;-1 - 失败
* history				: 
*****************************************************************/
//static int ThreadPoolDestroy (void *pthis) 
//{ 
//	CThread_pool_t *pool = (CThread_pool_t *)pthis;
//	
//    if (pool->shutdown) /**< 已销毁 */
//    {
//    	return -1;
//    }
//    pool->shutdown = 1;	/**< 销毁标志置位 */
//	
//    pthread_cond_broadcast (&(pool->queue_ready)); /**< 唤醒所有pthread_cond_wait()等待线程 */
//    int i; 
//    for (i = 0; i < pool->current_pthread_num; i++) 
//    {
//    	pthread_join (pool->threadid[i], NULL); /**< 等待所有线程执行结束 */
//    }
//	
//    free (pool->threadid);	/**< 释放 */
//    worker_t *head = NULL; 
//	
//    while (pool->queue_head != NULL) 
//    { 
//        head = pool->queue_head; 
//        pool->queue_head = pool->queue_head->next; 
//        free (head);	/**< 释放 */
//    } 
//	
//    pthread_mutex_destroy(&(pool->queue_lock));	/**< 销毁 */
//    pthread_cond_destroy(&(pool->queue_ready)); /**< 销毁 */     
//    free (pool);	/**< 释放 */ 
//    pool=NULL; 	
//    return 0; 
//} 


/****************************************************************
* function name 		: ThreadPoolRoutine
* functional description	: 线程池中运行的线程
* input parameter		: arg	线程池指针
* output parameter	: 
* return value			: NULL
* history				: 
*****************************************************************/
static void * ThreadPoolRoutine (void *arg) 
{ 
	pthread_detach(pthread_self());
	CThread_pool_t *pool = (CThread_pool_t *)arg;
	
    while (1) 
    { 
        pthread_mutex_lock (&(pool->queue_lock)); /**< 上锁, pthread_cond_wait()调用会解锁*/
		
        while ((pool->cur_queue_size == 0) && (!pool->shutdown))	/**< 队列没有等待任务*/
        { 
            pthread_cond_wait(&(pool->queue_ready), &(pool->queue_lock)); 	/**< 条件锁阻塞等待条件信号*/
		} 
        //if (pool->shutdown) 
        //{ 
        //    pthread_mutex_unlock (&(pool->queue_lock)); 
        //    pthread_exit (NULL); 	/**< 释放线程 */
        //} 

        assert (pool->cur_queue_size != 0); 
        assert (pool->queue_head != NULL); 
         
        pool->cur_queue_size--; 	/**< 等待任务减1,准备执行任务*/ 
        worker_t *worker 	= pool->queue_head;	/**< 取等待队列任务结点头*/ 
        pool->queue_head 	= worker->next; 	/**< 链表后移 */ 
		
        pthread_mutex_unlock (&(pool->queue_lock)); 
        (*(worker->process)) (worker->arg); 	/**< 执行回调函数 */ 
        pthread_mutex_lock (&(pool->queue_lock)); 
		
		pool->current_pthread_task_num--;	/**< 函数执行结束 */ 
        free (worker); 	/**< 释放任务结点 */
        worker = NULL; 

		if ((pool->current_pthread_num - pool->current_pthread_task_num) > pool->free_pthread_num)
		{
			pthread_mutex_unlock (&(pool->queue_lock)); 
			break;	/**< 当池中空闲线程超过 free_pthread_num则将线程释放回操作系统 */
		}
        pthread_mutex_unlock (&(pool->queue_lock)); 		
    } 
	
	pool->current_pthread_num--;	/**< 当前池中线程数减1 */
	//free(pool->threadid);
    pthread_exit (NULL);	/**< 释放线程*/
    return (void*)NULL;
} 

/****************************************************************
* function name 		: ThreadPoolConstruct
* functional description	: 创建线程池
* input parameter		: max_num	线程池可容纳的最大线程数
					  free_num	线程池允许存在的最大空闲线程,超过则将线程释放回操作系统
* output parameter	: 
* return value			: 线程池指针
* history				: 
*****************************************************************/
CThread_pool_t* ThreadPoolConstruct(int max_num,int free_num) 
{ 
    CThread_pool_t *pool = (CThread_pool_t *) malloc (sizeof (CThread_pool_t)); 
	if (NULL == pool)
	{
		return NULL;
	}
	memset(pool, 0, sizeof(CThread_pool_t));
	
    pthread_mutex_init (&(pool->queue_lock), NULL);	/**< 初始化互斥锁 */
    pthread_cond_init (&(pool->queue_ready), NULL);	/**< 初始化条件变量 */ 

    pool->queue_head 				= NULL; 
    pool->max_thread_num 			= max_num;	/**< 线程池可容纳的最大线程数 */
    pool->cur_queue_size 			= 0; 
	pool->current_pthread_task_num 	= 0;
    pool->shutdown 					= 0; 
	pool->current_pthread_num 		= 0;
	pool->free_pthread_num 			= free_num;	/**< 线程池允许存在的最大空闲线程 */
	pool->threadid					= NULL;
    pool->threadid 					= (pthread_t *) malloc (max_num * sizeof (pthread_t)); 
	pool->AddWorkUnlimit			= ThreadPoolAddWorkUnlimit;	/**< 给函数指针赋值 */
	pool->AddWorkLimit				= ThreadPoolAddWorkLimit;
	//pool->Destruct					= ThreadPoolDestroy;
	pool->GetMaxThreadNum			= ThreadPoolGetThreadMaxNum;
	pool->GetCurThreadNum			= ThreadPoolGetCurrentThreadNum;
	pool->GetCurTaskThreadNum		= ThreadPoolGetCurrentTaskThreadNum;
	pool->GetCurTaskNum				= ThreadPoolGetCurrentTaskNum;
	
    int i = 0; 
    for (i = 0; i < max_num; i++) 
    {  
		pool->current_pthread_num++;	/**< 当前池中的线程数 */
        pthread_create (&(pool->threadid[i]), NULL, ThreadPoolRoutine, (void*)pool);	/**< 创建线程 */
		usleep(1000);
    } 

	return pool;
} 

/****************************************************************
* function name 		: ThreadPoolConstructDefault
* functional description	: 创建线程池,以默认的方式初始化,未创建线程
* input parameter		: 
* output parameter	: 
* return value			: 线程池指针
* history				: 
*****************************************************************/
//CThread_pool_t* ThreadPoolConstructDefault(void) 
//{ 
//    CThread_pool_t *pool = (CThread_pool_t *) malloc (sizeof (CThread_pool_t)); 
//	if (NULL == pool)
//	{
//		return NULL;
//	}
//	memset(pool, 0, sizeof(CThread_pool_t));
//	
//    pthread_mutex_init(&(pool->queue_lock), NULL); 
//    pthread_cond_init(&(pool->queue_ready), NULL); 
//
//    pool->queue_head 				= NULL; 
//    pool->max_thread_num 			= DEFAULT_MAX_THREAD_NUM;	/**< 默认值 */
//    pool->cur_queue_size 			= 0; 
//	pool->current_pthread_task_num 	= 0;
//    pool->shutdown 					= 0; 
//	pool->current_pthread_num 		= 0;
//	pool->free_pthread_num 			= DEFAULT_FREE_THREAD_NUM;	/**< 默认值 */
//	pool->threadid					= NULL;
//	pool->AddWorkUnlimit			= ThreadPoolAddWorkUnlimit;
//	pool->AddWorkLimit				= ThreadPoolAddWorkLimit;
//	pool->Destruct					= ThreadPoolDestroy;
//	pool->GetMaxThreadNum			= ThreadPoolGetThreadMaxNum;
//	pool->GetCurThreadNum			= ThreadPoolGetCurrentThreadNum;
//	pool->GetCurTaskThreadNum		= ThreadPoolGetCurrentTaskThreadNum;
//	pool->GetCurTaskNum				= ThreadPoolGetCurrentTaskNum;
//	
//	return pool;
//}


//简单使用demo
#include <stdio.h>
#include <string.h>
#include "lib_thread_pool.h"

static int i = 0;
void *fun(void *arg)
{
    printf("i = %d\n", ++i);
}

int main()
{
    CThread_pool_t* pThreadPool = NULL;
    pThreadPool = ThreadPoolConstruct(10, 1);

    while(1)
    {
        pThreadPool->AddWorkLimit((void*)pThreadPool, fun, NULL);
        sleep(1);
    }
    return 0;
}

编译：

gcc -o test test.c lib_thread_pool.c -lpthread

 

参考：

https://blog.csdn.net/qq_36359022/article/details/78796784

https://www.cnblogs.com/jiangzhaowei/p/10383049.html

soulsoul_god
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C# 线程池使用示例
12-04
在VS2013环境下，结合控制台窗口，我们可以轻松地实现线程池的使用。下面将详细探讨C#线程池的工作原理、优势以及如何在实际项目中应用。 线程池的基本概念： 线程池是一组预先创建的线程，这些线程由操作系统维护...
java线程池使用后到底要关闭吗
08-26
java线程池使用后到底要关闭吗 java线程池是一种高效的并发编程技术，可以帮助开发者更好地管理线程资源，提高系统的性能和可靠性。然而，在使用java线程池时，一个常见的问题是：使用完线程池后到底要不要关闭？...
python 线程池使用
小胖_@的博客
08-05 7362
当线程池初始化时，会自动创建指定数量的线程，有任务到达时直接从线程池中取一个空闲线程来用即可，当任务执行结束时线程不会消亡而是直接进入空闲状态，继续等待下一个任务。而随着任务的增加线程池中的可用线程必将逐渐减少，当减少至零时，任务就需要等待了。在 python 中使用线程池有两种方式：一、是基于第三方库 threadpool二、是基于 python3 新引入的库 concurrent.futures.ThreadPoolExecutor。......
java线程池使用最全详解
热门推荐
qq_40093255的博客
05-18 8万+
线程池使用 前言 在执行一个异步任务或并发任务时，往往是通过直接new Thread()方法来创建新的线程，这样做弊端较多，更好的解决方案是合理地利用线程池，线程池的优势很明显，如下： 降低系统资源消耗，通过重用已存在的线程，降低线程创建和销毁造成的消耗； 提高系统响应速度，当有任务到达时，无需等待新线程的创建便能立即执行； 方便线程并发数的管控，线程若是无限制的创建，不仅会额外消耗大量系统资源，更是占用过多资源而阻塞系统或oom等状况，从而降低系统的稳定性。线程池能有效管控线程，统一分配、调优，提供资源
Android开发中的线程池使用
u012514113的专栏
12-24 3193
Android 线程池的使用 ThreadPoolExecutor
一. ThreadPoolExecutor线程池使用
DogLee奋斗屋
01-10 1034
线程池是Java中使用较多的并发框架，合理使用线程池，可以：降低资源消耗，提高响应速度，提高线程的可管理性。本篇文章为《Java并发编程的艺术》第9章的学习笔记，根据原文作者的编写思路，依次对线程池的原理，线程池的创建，线程池执行任务和关闭线程池进行了学习和总结。
Spring 线程池使用
m0_67266787的博客
04-25 2079
Spring 中默认自带线程池_org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor，一般有可以直接使用，这是时候使用的是默认的配置，直接使用_@Autowired注入使用 @Autowired private ThreadPoolTaskExecutor poolTaskExecutor; package com.timespark.door.test; import org.junit.Test; import org.j
spring线程池使用
qq_43538158的博客
04-23 1197
为何使用多线程 对于复杂的业务逻辑下，有时候需要使用多线程执行，以优化项目的执行速度 单线程同步执行的场景中，如果前边出现异常，会导致所有任务中断，异步执行没有这样的问题 ...
java线程池使用
sjjskshs的博客
07-04 2572
java中经常使用到多线程来处理业务，我们非常不建议单纯的使用Thread和Runnable接口的方法来创建线程，那必须有创建及销毁线程的耗费资源，线程上下文切换的问题，同时创建过多的线程也可能引发资源耗尽的风险，这个时候引入线程池比较合理，方便线程任务的管理.java中涉及到打的线程池相关的类均在jdk１.５开始的java.util.concurrent包中，设计到几个核心的类和接口，Executor,Executors,ExecutorService,ThreadPoolExecutor、FutureT
自定义线程池使用实例
磊杰的博客
01-28 1403
自定义拒绝策略、自定义ThreadFactory、自定义线程池 package com.wucj.controller.thread; import com.alibaba.fastjson.JSON; import com.wucj.entity.MessageEntity; import com.wucj.utils.UUIDUtils; import lombok.extern.s...
java 线程池 使用实例
apple_4872330的专栏
04-20 6781
java 线程池 使用实例 1 线程池做什么 网络请求通常有两种形式： 第一种，请求不是很频繁，而且每次连接后会保持相当一段时间来读数据或者写数据，最后断开，如文件下载，网络流媒体等。 另一种形式是请求频繁，但是连接上以后读/写很少量的数据就断开连接。考虑到服务的并发问题，如果每个请求来到以后服务都为它启动一个线程，那么这对服务的资源可能会造成很大的浪费，特别是第二种情况。 因为通常情况下，创建线程是需要一定的耗时的，设这个时间为T1，而连接后读/写服务的时间为T2，当T1>>T2时，
线程池使用Demo
05-06
线程池是Java并发编程中的重要概念，它是一种线程使用模式，用于高效地管理和执行大量并发任务。在Java中，我们主要通过`java.util.concurrent`包中的`ExecutorService`接口及其实现类来创建和管理线程池。线程池的...
Java线程池使用说明
02-24
Java线程池使用说明Java线程池使用说明Java线程池使用说明
C语言读写文件
背着行囊去远方的博客
04-21 5万+
一：打开文件句柄 //参数1：文件路径 //参数2：文件打开模式 函数执行成功返回文件流指针，错误返回NULL。 FILE *fopen(const char *path, const char *mode); 模式 操作 区别 文件要求 r 读 ...
cJSON构造与解析json
背着行囊去远方的博客
06-11 9974
参考： http://blog.sina.com.cn/s/blog_a6fb6cc90101ffme.html
C语言解析pcap数据包格式
背着行囊去远方的博客
02-25 9807
通过tcpdump命令或者wireshark抓取数据包。 如下图所示： pcap文件格式： 24字节pcap文件头+（16字节pcap数据包头+数据包）*n 解析源码如下： #include<stdio.h> #include<string.h> #include<stdlib.h> #include<netinet/in.h> ...
socket通信(ipv4,ipv6)
背着行囊去远方的博客
12-22 7395
实现socket通信，IPV4地址与IPV6地址。   服务端：server.c #include &lt;sys/types.h&gt; #include &lt;sys/socket.h&gt; #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;errno.h&gt; #include &lt;string....
guawa 线程池使用
最新发布
12-09
Guava中的线程池使用可以通过`ListeningExecutorService`接口来实现。该接口继承自`ExecutorService`，并添加了`ListenableFuture`支持，可以在任务完成时触发回调函数。以下是一个简单的例子： ```java // 创建线程池 ExecutorService executorService = Executors.newFixedThreadPool(10); ListeningExecutorService listeningExecutorService = MoreExecutors.listeningDecorator(executorService); // 提交任务 ListenableFuture<String> future = listeningExecutorService.submit(() -> { // 执行任务 return "result"; }); // 添加回调函数 Futures.addCallback(future, new FutureCallback<String>() { @Override public void onSuccess(String result) { // 处理成功结果 } @Override public void onFailure(Throwable t) { // 处理异常情况 } }); ``` 上述代码中，首先通过`Executors.newFixedThreadPool(10)`创建一个固定大小为10的线程池，然后通过`MoreExecutors.listeningDecorator(executorService)`将其转换为`ListeningExecutorService`。接着，通过`listeningExecutorService.submit()`方法提交一个任务，并返回一个`ListenableFuture`对象。最后，通过`Futures.addCallback()`方法添加回调函数，当任务执行完成时，会自动触发回调函数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值