系统编程八：线程池

最新推荐文章于 2024-06-12 15:58:20 发布
最新推荐文章于 2024-06-12 15:58:20 发布
阅读量66 收藏
点赞数
分类专栏： Linux系统编程 文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53809203/article/details/132919408
版权

一、分析线程池文件

pool_test/  -> 线程池的源码
        thread_pool.c  -> 线程池函数接口源码  -> 待会主要分析这个文件
        thread_pool.h  -> 线程池函数声明、线程池结构体..
        main.c   -> 简单应用。
线程池接口设计说明书.doc  -> 详细说明了线程池中函数的用法。

二、线程池实现过程

1、 什么是线程池？

        线程池就是多个线程组合起来的一个集合，就好像一家公司，由多个员工组成的一个集合。当有任务时，这些线程就会去处理这些任务，当没有任务时，线程就会休息。

2、 如何来描述一个线程池？  -> 使用一个结构体

typedef struct thread_pool
{
	pthread_mutex_t lock;    -> 互斥锁
	pthread_cond_t  cond;    -> 条件变量
	bool shutdown;		 -> 当前线程池的标志位  true -> 线程池关闭了，  false  -> 线程池没有关闭。
	struct task *task_list;  -> 任务队列的头节点
	pthread_t *tids;         -> 储存所有线程的ID号
	//unsigned max_waiting_tasks;  -> 最大等待任务的数目
	unsigned waiting_tasks;	     -> 当前正在等待处理的任务的个数//链表中有多少个结点，每个结点就是一个任务，也就是当前有多少个任务
	unsigned active_threads;     -> 活跃的线程个数 //表示当前线程池里面有多少条线程
	
}thread_pool;

//任务队列 的结点数据类型---- 也就是说 任务结构体的数据类型
struct task
{
	/* 数据域 */
	void *(*do_task)(void *arg); //函数指针 -> 这个任务需要执行的函数，这个函数必须是: void *fun(void *arg)
	void *arg;    -> 传递给执行的函数的参数

	/* 指针域 */
	struct task *next;  -> 指向下一个任务节点的指针。
};

3、 如何实现初始化？  -> init_pool()

bool init_pool(thread_pool *pool, unsigned int threads_number)
{
	//1. 初始化线程池互斥锁
	pthread_mutex_init(&pool->lock, NULL);
	
	//2. 初始化条件变量
	pthread_cond_init(&pool->cond, NULL);

	//3. 初始化标志位为false，代表当前线程池正在运行。
	pool->shutdown = false;
	
	//4. 初始化任务队列的头节点
	pool->task_list = malloc(sizeof(struct task));
	
	//5. 为储存线程ID号申请空间。
	pool->tids = malloc(sizeof(pthread_t) * MAX_ACTIVE_THREADS);

	//第4步与第5步错误判断
	if(pool->task_list == NULL || pool->tids == NULL)
	{
		perror("allocate memory error");
		return false; //初始化线程池失败
	}

	//6. 为线程池任务队列的头节点的指针域赋值NULL
	pool->task_list->next = NULL;
	
	//7. 设置线程池最大任务个数为1000
	pool->max_waiting_tasks = MAX_WAITING_TASKS;
	
	//8. 当前需要处理的任务为0
	pool->waiting_tasks = 0;
	
	//9. 初始化线程池中线程池的个数
	pool->active_threads = threads_number;

	//10. 创建线程
	int i;
	for(i=0; i<pool->active_threads; i++)
	{
		if(pthread_create(&((pool->tids)[i]), NULL,routine, (void *)pool) != 0)
		{
			perror("create threads error");
			return false;
		}
	}

	//11. 线程池初始化成功
	return true;
}

总结：

        初始化线程池函数其实就是给线程池的结构体赋值，将一些变量赋初值，以及初始化变量，为指针申请空间。

4、如何添加任务呢？  ->  add_task()

bool add_task(thread_pool *pool,void *(*do_task)(void *arg), void *arg)
{
	//1. 为新任务的节点申请空间
	struct task *new_task = malloc(sizeof(struct task));
	if(new_task == NULL)
	{
		perror("allocate memory error");
		return false;
	}
	
	//2. 为新节点的数据域与指针域赋值
	new_task->do_task = do_task;  
	new_task->arg = arg; 
	new_task->next = NULL;  
	
	//3.  在添加任务之前，必须先上锁，因为添加任务属于访问临界资源 -> 任务队列
	pthread_mutex_lock(&pool->lock);
	
	//4. 如果当前需要处理的任务个数>=1000
	if(pool->waiting_tasks >= MAX_WAITING_TASKS)
	{
		//解锁
		pthread_mutex_unlock(&pool->lock);
		
		//打印一句话提示一下，太多任务了
		fprintf(stderr, "too many tasks.\n");
		
		//释放掉刚刚准备好的新节点
		free(new_task);

		return false;
	}
	
	//5. 寻找任务队列中的最后一个节点
	struct task *tmp = pool->task_list;
	while(tmp->next != NULL)
		tmp = tmp->next;
	//从循环中出来时，tmp肯定是指向最后一个节点
	
	//6. 让最后一个节点的指针域指向新节点
	tmp->next = new_task;
	
	//7. 当前需要处理的任务+1
	pool->waiting_tasks++;

	//8. 添加完毕，就解锁。
	pthread_mutex_unlock(&pool->lock);

	//9. 唤醒条件变量中的一个线程起来做任务
	pthread_cond_signal(&pool->cond);
	
	return true;
}

总结：

插入一个新节点到任务队列的末尾，唤醒条件变量中的一个线程起来做任务。

5、线程例程函数  -> void *routine(void *arg)

void *routine(void *arg)
{
	//1. 先接住线程池的地址
	thread_pool *pool = (thread_pool *)arg;
	struct task *p;

	while(1)
	{
		//2. 线程取消例程函数
		//将来要是有人要取消我，请先把锁解开，然后再响应取消。
		pthread_cleanup_push(handler, (void *)&pool->lock);
		
		//3. 上锁
		pthread_mutex_lock(&pool->lock);
		
		//如果当前线程池没有关闭，并且当前线程池没有任务做
		while(pool->waiting_tasks == 0 && !pool->shutdown)
		{
			//那么就进去条件变量中睡觉。
			pthread_cond_wait(&pool->cond, &pool->lock); //自动解锁
		}
		
		//要是线程池关闭了，或者有任务做，这些线程就会运行到这行代码
		//判断当前线程池是不是关闭了，并且没有等待的任务
		if(pool->waiting_tasks == 0 && pool->shutdown == true)
		{	
			//如果线程池关闭，又没有任务做
			//线程那么就会解锁
			pthread_mutex_unlock(&pool->lock);	
			
			//线程走人
			pthread_exit(NULL); 
		}
		
		//能运行到这里，说明有任务做
		//p指向头节点的下一个
		p = pool->task_list->next;
		
		//让头节点的指针域指向p的下一个节点
		pool->task_list->next = p->next;
		
		//当前任务个数-1
		pool->waiting_tasks--;

		//解锁
		pthread_mutex_unlock(&pool->lock);
		
		//删除线程取消例程函数
		pthread_cleanup_pop(0);
		
		//设置线程不能响应取消
		pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL); 
		
		//执行这个p节点指向的节点的函数
		(p->do_task)(p->arg);
		
		//设置线程能响应取消
		pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);

		//释放p对应的空间
		free(p);
	}

	pthread_exit(NULL);
}

总结：

        线程去任务队列中拿一个节点出来，就执行该任务(过程不能被取消)，如果没有任务做，就去睡觉。

6、添加线程  -> add_thread()

int add_thread(thread_pool *pool, unsigned additional_threads)
{
	//如果说你想添加0条，则直接返回0。
	if(additional_threads == 0)
		return 0; 

	unsigned total_threads = pool->active_threads + additional_threads;
			 //total_threads = 原本 2条 + 现在再加2条
						
	int i, actual_increment = 0;
	
	// i = 2 ; i<4 && i<20; i++
	for(i = pool->active_threads; i < total_threads && i < MAX_ACTIVE_THREADS;  i++) 
	{
		if(pthread_create(&((pool->tids)[i]),NULL, routine, (void *)pool) != 0)
		{
			perror("add threads error");
			if(actual_increment == 0) 
				return -1;

			break;
		}
		actual_increment++;  //真正创建线程的条数
	}

	pool->active_threads += actual_increment; //当前线程池线程个数 = 原来的个数 + 实际创建的个数
	
	return actual_increment; //返回真正创建的个数
}

总结：

根据用户的需要去创建线程，但是不能超过20条。

7、删除线程  -> remove_thread()

int remove_thread(thread_pool *pool, unsigned int removing_threads)
{
	//1. 如果你想删0条，直接返回。
	if(removing_threads == 0)
		return pool->active_threads;  //返回当前剩余的线程数

	int remaining_threads = pool->active_threads - removing_threads;
	//            3         =            5         -  2
	//			  0			=	         5         -  5
	//           -3         =            5         -  8

	remaining_threads = remaining_threads > 0 ? remaining_threads : 1;

	int i;  
	for(i=pool->active_threads-1; i>remaining_threads-1; i--)
	{	
		errno = pthread_cancel(pool->tids[i]); //取消这些线程
		if(errno != 0)
			break;
	}

	if(i == pool->active_threads-1) //删除失败
		return -1;
	else
	{
		pool->active_threads = i+1; //当前实际线程个数
		return i+1; 
	}
}

总结：

根据用户需要，去取消掉一些线程，但是线程池中线程不能小于1条。

8、销毁线程池。  ----> destroy_pool() 

bool destroy_pool(thread_pool *pool)
{
	//1. 设置线程池关闭标志为真
	pool->shutdown = true; 
	
	pthread_cond_broadcast(&pool->cond);  //目的： 就是让线程退出！
	
	//2. 接合所有的线程
	int i;
	for(i=0; i<pool->active_threads; i++)
	{
		errno = pthread_join(pool->tids[i], NULL);

		if(errno != 0)
		{
			printf("join tids[%d] error: %s\n",
					i, strerror(errno));
		}
	
		else
			printf("[%u] is joined\n", (unsigned)pool->tids[i]);
		
	}

	//3. 释放一些空间
	free(pool->task_list);
	free(pool->tids);
	free(pool);

	return true;
}

总结： 唤醒所有的小孩，让小孩走人。

三、实例

1、main.c

#include "thread_pool.h"

void *mytask(void *arg) //线程的任务
{
	int n = *(int*)arg;

	//工作任务：余数是多少，就睡多少秒，睡完，任务就算完成
	printf("[%u][%s] ==> job will be done in %d sec...\n",
		(unsigned)pthread_self(), __FUNCTION__, n);

	sleep(n);

	printf("[%u][%s] ==> job done!\n",
		(unsigned)pthread_self(), __FUNCTION__);

	return NULL;
}

void *count_time(void *arg)
{
	int i = 0;
	while(1)
	{
		sleep(1);
		printf("sec: %d\n", ++i);
	}
}

int main(void)
{
	// 本线程用来显示当前流逝的秒数
	// 跟程序逻辑无关
	pthread_t a;
	pthread_create(&a, NULL, count_time, NULL);

	// 1, initialize the pool 申请线程池结构体内存空间
	thread_pool *pool = malloc(sizeof(thread_pool));
	init_pool(pool, 2);
	//2个线程都在条件变量中睡眠

	// 2, throw tasks
	printf("throwing 3 tasks...\n");
	int aa = (rand()%10);
	int b = (rand()%10);
	int c = (rand()%10);
	
	//添加任务
	add_task(pool, mytask, (void *)&aa);
	add_task(pool, mytask, (void *)&b);
	add_task(pool, mytask, (void *)&c);

	// 3, check active threads number
	printf("current thread number: %d\n",
			remove_thread(pool, 0));//2
	sleep(9);

	// 4, throw tasks
	printf("throwing another 6 tasks...\n");
	
	int d,e,f,g,h,j;
	d = (rand()%10);
	e = (rand()%10);
	f = (rand()%10);
	g = (rand()%10);
	h = (rand()%10);
	j = (rand()%10);
	
	add_task(pool, mytask, (void *)&d);
	add_task(pool, mytask, (void *)&e);
	add_task(pool, mytask, (void *)&f);
	add_task(pool, mytask, (void *)&g);
	add_task(pool, mytask, (void *)&h);
	add_task(pool, mytask, (void *)&j);
	
	// 5, add threads
	add_thread(pool, 2);

	sleep(5);

	// 6, remove threads
	printf("remove 3 threads from the pool, "
	       "current thread number: %d\n",
			remove_thread(pool, 3));

	// 7, destroy the pool
	destroy_pool(pool);
	return 0;
}

2、thread_pool.h

#ifndef _THREAD_POOL_H_
#define _THREAD_POOL_H_

#include <stdio.h>
#include <stdbool.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>

#include <errno.h> //系统全局变量 errno要添加的头文件
#include <pthread.h>

#define MAX_WAITING_TASKS	1000
#define MAX_ACTIVE_THREADS	20  //当前线程池 最多能 支持加载运行的线程数量

struct task
{
	void *(*do_task)(void *arg);
	void *arg;

	struct task *next;
};
//线程池结构体的数据类型设计
typedef struct thread_pool
{
	pthread_mutex_t lock;
	pthread_cond_t  cond;
	bool shutdown;
	struct task *task_list;
	pthread_t *tids;
	unsigned max_waiting_tasks;
	unsigned waiting_tasks;
	unsigned active_threads;
}thread_pool;


bool init_pool(thread_pool *pool, unsigned int threads_number);
bool add_task(thread_pool *pool, void *(*do_task)(void *arg), void *task);
int  add_thread(thread_pool *pool, unsigned int additional_threads_number);
int  remove_thread(thread_pool *pool, unsigned int removing_threads_number);
bool destroy_pool(thread_pool *pool);

void *routine(void *arg);


#endif

3、thread_pool.c

#include "thread_pool.h"

void handler(void *arg)
{
	printf("[%u] is ended.\n",
		(unsigned)pthread_self());

	//解锁
	pthread_mutex_unlock((pthread_mutex_t *)arg);
}

void *routine(void *arg)
{
	//1. 先接住线程池的地址
	thread_pool *pool = (thread_pool *)arg;
	struct task *p;

	while(1)
	{
		//2. 线程取消例程函数
		//将来要是有人要取消我，请先把锁解开，然后再响应取消。
		//压栈的线程取消处理例程
		pthread_cleanup_push(handler, (void *)&pool->lock);
		
		//3. 上锁
		pthread_mutex_lock(&pool->lock);
		
		//如果当前线程池没有关闭，并且当前线程池没有任务做
		while(pool->waiting_tasks == 0 && pool->shutdown == false) //pool->shutdown == false 等价于 !pool->shutdown
		{
			//那么就进去条件变量中睡觉。--摸鱼
			pthread_cond_wait(&pool->cond, &pool->lock); //自动解锁
		}
		
		//要是线程池关闭了，或者有任务做，这些线程就会运行到这行代码
		//判断当前线程池是不是关闭了，并且没有等待的任务
		if(pool->waiting_tasks == 0 && pool->shutdown == true)
		{	
			//如果线程池关闭，又没有任务做
			//线程那么就会解锁
			pthread_mutex_unlock(&pool->lock);	
			
			//线程走人
			pthread_exit(NULL); 
		}
		
		//能运行到这里，说明有任务做 而且线程池 还在运行
		//p指向头节点的下一个
		p = pool->task_list->next;
		
		//让首节点的指针域指向p的下一个节点
		pool->task_list->next = p->next;
		
		//当前任务个数-1
		pool->waiting_tasks--;

		//解锁
		pthread_mutex_unlock(&pool->lock);
		
		//删除线程取消例程函数
		pthread_cleanup_pop(0);
		
		//设置线程不能响应取消
		pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL); 
		
		//执行这个p节点指向的节点的函数  ---相当于 调用  eat(NULL)  playGame(NULL)
		(p->do_task)(p->arg);
		
		//设置线程能响应取消
		pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);

		//释放p对应的空间
		free(p);
	}

	pthread_exit(NULL);
}

bool init_pool(thread_pool *pool, unsigned int threads_number)
{
	//1. 初始化线程池互斥锁
	pthread_mutex_init(&pool->lock, NULL);
	
	//2. 初始化条件变量
	pthread_cond_init(&pool->cond, NULL);

	//3. 初始化标志位为false，代表当前线程池正在运行。
	pool->shutdown = false;
	
	//4. 初始化任务队列的数据首节点---而且这个数据首结点不存储数据
	pool->task_list = malloc(sizeof(struct task));

	//5. 为储存线程ID号申请空间。 ---相当于  pthread_t tids[20]
	pool->tids = malloc(sizeof(pthread_t) * MAX_ACTIVE_THREADS);

	//第4步与第5步错误判断
	if(pool->task_list == NULL || pool->tids == NULL)
	{
		perror("allocate memory error");
		return false; //初始化线程池失败
	}

	//6. 为线程池任务队列的头节点的指针域赋值NULL
	pool->task_list->next = NULL;
	
	//7. 设置线程池最大任务个数为1000
	pool->max_waiting_tasks = MAX_WAITING_TASKS;
	
	//8. 当前需要处理的任务为0 ---也就是当前任务队列（链表）的 任务结点的个数 ---nodeNumber
	pool->waiting_tasks = 0;
	
	//9. 初始化线程池中线程池的个数
	pool->active_threads = threads_number;

	//10. 创建线程,创建的每个线程ID号存储到tids
	int i;
	for(i=0; i<pool->active_threads; i++)
	{
		if(pthread_create(&((pool->tids)[i]), NULL,routine, (void *)pool) != 0)
		{
			perror("create threads error");
			return false;
		}
	}

	//11. 线程池初始化成功
	return true;
}
//添加任务----到任务队列（链表）中
bool add_task(thread_pool *pool,void *(*do_task)(void *arg), void *arg)
{
	//1. 为新任务的节点申请空间 ---新建一个数据结点 newNode
	struct task *new_task = malloc(sizeof(struct task));
	if(new_task == NULL)
	{
		perror("allocate memory error");
		return false;
	}
	
	//2. 为新节点的数据域与指针域赋值
	new_task->do_task = do_task;  
	new_task->arg = arg; 
	new_task->next = NULL;  
	
	//3.  在添加任务之前，必须先上锁，因为添加任务属于访问临界资源 -> 任务队列
	pthread_mutex_lock(&pool->lock);
	
	//4. 如果当前需要处理的任务个数>=1000
	if(pool->waiting_tasks >= MAX_WAITING_TASKS)
	{
		//解锁
		pthread_mutex_unlock(&pool->lock);
		
		//打印一句话提示一下，太多任务了
		fprintf(stderr, "too many tasks.\n");
		
		//释放掉刚刚准备好的新节点
		free(new_task);

		return false;
	}
	
	//5. 寻找任务队列中的最后一个节点
	struct task *p = pool->task_list;
	while(p->next != NULL)
		p = p->next;
	//从循环中出来时，p肯定是指向最后一个节点
	
	//6. 让最后一个节点的指针域指向新节点
	p->next = new_task;
	
	//7. 当前需要处理的任务+1  ----结点的数量 +1
	pool->waiting_tasks++;

	//8. 添加完毕，就解锁。
	pthread_mutex_unlock(&pool->lock);

	//9. 唤醒条件变量中的一个线程起来做任务
	pthread_cond_signal(&pool->cond);
	
	return true;
}

int add_thread(thread_pool *pool, unsigned additional_threads)
{
	//如果说你想添加0条，则直接返回0。
	if(additional_threads == 0)
		return 0; 

	unsigned total_threads = pool->active_threads + additional_threads;
				//total_threads = 原本 2条 + 再加2条 
			 //total_threads = 原本 2条 + 现在再加20条  //第19条  第 20条 创建失败 i = 20  i=21
						
	int i, actual_increment = 0;
	
	// i = 2 ; i<22 && i<20; i++
	// i = 2 ; i<4 && i<20; i++
	for(i = pool->active_threads; i < total_threads && i < MAX_ACTIVE_THREADS;  i++) 
	{
		if(pthread_create(&((pool->tids)[i]),NULL, routine, (void *)pool) != 0) //tids[0]  tids[1]  tids[2]
		{
			perror("add threads error");
			if(actual_increment == 0) 
				return -1;

			break;
		}
		actual_increment++;  //真正创建线程的条数
	}

	pool->active_threads += actual_increment; //当前线程池线程个数 = 原来的个数 + 实际创建的个数
	
	return actual_increment; //返回真正创建的个数
}

     
int remove_thread(thread_pool *pool, unsigned int removing_threads)
{
	//1. 如果你想删0条，直接返回。
	if(removing_threads == 0)
		return pool->active_threads;  //返回当前剩余的条数

	int remaining_threads = pool->active_threads - removing_threads;
	//            1         =            4         -  3
	//			  -1		=	         4         -  5


	remaining_threads = remaining_threads > 0 ? remaining_threads : 1;

	int i;  
	//现在线程数 有4 条，要移除3条   tids[0] tids[1] tids[2] tids[3]
	// i = 4-1 ; i>1-1; i-- 
	// i = 3; i>0; i-- 
	for(i=pool->active_threads-1; i>remaining_threads-1; i--) //i ==3 i==2 i==1
	{	
		//errno 是一个系统全局变量 专门用来记录错误码 错误码 可以通过 perror 
		errno = pthread_cancel(pool->tids[i]); //取消这些线程
		if(errno != 0)//出错了
			break;
	}
	// i == 0
	
	//i == 4-1 -->3
	if(i == pool->active_threads-1) //删除失败
		return -1;
	else
	{
		pool->active_threads = i+1; //当前实际线程个数
		return i+1; 
	}
}


bool destroy_pool(thread_pool *pool)
{
	//1. 设置线程池关闭标志为真
	pool->shutdown = true; 
	//2、唤醒全部的线程
	pthread_cond_broadcast(&pool->cond);  //目的： 就是让线程退出！
	
	//2. 接合所有的线程
	int i;
	for(i=0; i<pool->active_threads; i++)
	{
		errno = pthread_join(pool->tids[i], NULL);

		if(errno != 0)
		{
			printf("join tids[%d] error: %s\n",
					i, strerror(errno));
		}
	
		else
			printf("[%u] is joined\n", (unsigned)pool->tids[i]);
		
	}

	//3. 释放一些空间
	free(pool->task_list);
	free(pool->tids);
	free(pool);

	return true;
}

4、Makefile

CC = gcc
CFLAGS = -O0 -Wall -g -lpthread

test:main.c thread_pool.c
	$(CC) $^ -o $@ $(CFLAGS)

debug:main.c thread_pool.c
	$(CC) $^ -o $@ $(CFLAGS) -DDEBUG

clean:
	$(RM) .*.sw? test debug *.o

.PHONY:all clean

阿哈、小吴
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
线程池详解：线程池七大核心参数、线程池工作原理、线程池的创建方式、线程池的拒绝策略、如何合理分配线程池大小
小小鱼儿小小林的博客
03-19 8999
线程池是一种用于管理和复用线程的机制，它允许我们在需要执行一些并发任务时，可以重复使用已经创建好的线程，而不是每次都创建新的线程。这样可以减少线程创建和销毁的开销，提高系统的性能和响应速度。并发线程池的优点包括： 提高系统的性能和吞吐量，因为可以重复使用已经创建好的线程，减少线程创建和销毁的开销。 可以控制并发任务的执行顺序和数量，从而避免系统资源被过度占用。 可以设置线程池的参数，如核心线程数、最大线程数、任务队列等，以满足不同场景的需求。
并发编程经历：线程池的使用
热门推荐
yjclsx的博客
07-31 42万+
线程池的使用 使用线程池管理线程可以最大程度的利用线程,节省资源消耗，它通过利用已有的线程多次循环执行多个任务从而提高系统的处理能力。 我们可以通过java.util.concurrent.ThreadPoolExecutor类来创建线程池，一个任务通过execute(Runnable)方法被添加到线程池，任务就是一个Runnable类型的对象，任务的执行方法就是Runnable类型对象的...
并发编程（三）：线程池基本面试题（必背题目）
无痕之剑的书橱
03-29 1万+
一、背景 金三银四话说是跳槽的最佳时机，各大公司也在此时招兵买马，当然面试者也很多，基本上一个面试官至少2场面试，而面试者也旗鼓相当，每天面2家的节奏。我本人也参加了一些公司的面试，发现线程池被问到的概率达到50%以上，而且问的问题大概就那几个，没啥新意。唯一有新意的是一个架构师问我“如何设计一个线程池”，虽然看过，但是没有理解，忘了！！！好记性不如烂笔头，还是记录下吧。 二、高频面试题（八股文） 1、什么是线程池？线程池有什么好处（被问概率很小）？ 所谓线程池，通俗来讲，就是一个管理线程的池子。它
C++并发编程：线程池学习
qq_45797625的博客
03-14 1011
类模版 std::function 是一种通用、多态的函数封装，可以对任何可以调用的目标实体进行存储、复制、和调用操作，这些目标实体包括普通函数、Lambda表达式、函数指针、以及其它函数对象等std::function 对象是对C++中现有的可调用实体的一种类型安全的包裹（我们知道像函数指针这类可调用实体，是类型不安全的）
异步编程：线程池和CompletableFuture
weixin_51980608的博客
05-28 1222
线程池是一种利用池化技术思想来实现的线程管理技术，主要是为了复用线程、便利地管理线程和任务、并将线程的创建和任务的执行解耦开来。我们可以创建线程池来复用已经创建的线程来降低频繁创建和销毁线程所带来的资源消耗。在JAVA中主要是使用类来创建线程池，并且JDK中也提供了Executors工厂类来创建线程池（不推荐使用）。线程池的优点：降低资源消耗，复用已创建的线程来降低创建和销毁线程的消耗。提高响应速度，任务到达时，可以不需要等待线程的创建立即执行。提高线程的可管理性。
并发编程：线程池介绍
qq_40662405的博客
06-18 529
JAVA 中的线程池是应用场景最多的并发框架，几乎所有需要异步或并发执行任务的程序都可以使用线程池。在阿里巴巴《java 开发手册》中甚至说明。足以显示线程池的重要性。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。对操作系统来说,创建一个线程的代价是十分昂贵的, 需要给它分配内存、列入调度，同时在线程切换的时候还要执行内存换页，CPU 的缓存被清空,切换回来的时候还要重新从内存中读取信息,破坏了数据的局部性。任务到达时，任务可以不需要等待线程创建完毕。线程是稀缺资源。如果无限制的创建。不仅会消耗系
Java并发编程实战：线程池、锁和原子操作
silenceallat的博客
03-10 834
文章标题：《Java并发编程实战：线程池、锁和原子操作》 摘要：本文深入探讨了Java并发编程的核心主题——线程池、锁和原子操作。通过生动的比喻和生活实例，我们介绍了这些概念的应用场景和实战技巧。线程池像一个智能的结账系统，提高了任务处理的效率；锁确保了数据的一致性和完整性；原子操作则保证了并发环境下的安全性和准确性。掌握这些技术，可以让我们编写出高性能、高可靠性的并发程序。
并发编程:线程池ThreadPoolExecutor的理解
wang5701071的博客
03-11 526
ThreadPoolExecutor是java.util.concurrent包下的线程池,继承ExecutorService类.《阿里巴巴Java开发手册》中强制线程池不允许使用 Executors 去创建，而是通过 new ThreadPoolExecutor 实例的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。
Java并发编程：线程池
rrq_0324的博客
12-04 1032
1. 基础知识 1.1 线程池的特点 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。（线程复用） 提高响应速度。当任务到达时，任务可以不需要等待线程创建就能立即执行。 提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配、调优和监控。（控制最大并发数） 1.2 异步回调 同步和异步通常用来形容一次方法调用。 同步方法调用一旦开始，调用者必须等到方法调用返回后，才能继续后续的行为。 异步方法调用一旦开始，方法调
Java并发编程：线程池的使用
Java技术江湖
08-12 1460
Java并发编程：线程池的使用 　　在前面的文章中，我们使用线程的时候就去创建一个线程，这样实现起来非常简便，但是就会有一个问题： 　　如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。 　　那么有没有一种办法使得线程可以复用，就是执行完一个任务，并不被销毁，而是可以继续执行其他的任务？ 　　在Java中可以通过线程池来达到这样的效果。今天我们就来详细讲解一下Java的线程池，首先我们从最核心的Thre
java并发编程：juc线程池
08-09
了解并发编程和线程池的工作原理，可以让您充分利用多核处理器，同时处理多个任务，提高系统的性能和响应速度。JUC 线程池管理线程的创建、复用和销毁，有效地减少了线程频繁创建和销毁所带来的开销，从而提高了系统...
Linux C系统编程：使用线程池实现cp命令
08-27
C语言线程池实现实例
Python 程序语言设计模式思路-并发模式：线程池模式：管理线程池，优化线程创建和销毁
05-22
线程池模式（Thread Pool Pattern）是一种优化线程管理的设计模式，它通过创建一个线程池来管理和复用线程，从而避免频繁的线程创建和销毁，提高系统性能。线程池模式适用于需要频繁执行大量短生命周期任务的场景，...
深入理解高并发编程-Java线程池核心技术
06-01
java并发编程实战pdf 线程与多线程 1.线程 在操作系统中，线程是比进程更小的能够独立运行的基本单位。同时，它也是 CPU 调度的基本单位。线程本身基本上不拥有系统资源，只是拥有一些在运行时 需要用到的系统资源...
线程池拷贝目录程序代码
03-01
利用线程池实现拷贝目录的效果，让其效果等同于cp命令。
Linux fallocate工具用于预分配或释放文件空间的块
不积跬步，无以至千里；不积小流，无以成江海。
06-09 297
命令，您需要在具有适当权限的环境中运行它，例如通过SSH登录到Linux服务器或在Linux终端中运行。请确保指定的路径存在且可写。文件中未使用的磁盘空间。请注意，这不会改变文件的大小，只是释放了未使用的磁盘空间。之前，建议了解文件系统和存储设备的特性，以避免潜在的性能问题。是一个Linux命令行工具，用于预分配或释放文件空间的块。文件的大小截断为5MB。大于5MB的部分将被删除。文件的10MB偏移量处开始预分配5MB的磁盘空间。文件的10MB偏移量处开始的5MB磁盘空间。文件预分配10MB的磁盘空间。
解决 Linux 和 Java 1.8 中上传中文名称图片报错问题
appearappear的博客
06-12 213
在 Linux 系统和 Java 1.8 中，当尝试上传含有中文名称的图片时，可能会遇到以下错误提示：为了解决这个问题，可以采取以下方法：在 Docker 的 中添加如下参数：Dockerfile使用以下命令启动 Java 程序，添加 参数：通过以上配置，确保了在启动 Java 程序时，使用了 UTF-8 编码，这样可以正确处理含有中文名称的文件，避免了报错问题的发生。3.5
linux中: IDEA 由于JVM 设置内存过小，导致打开项目闪退问题
最新发布
m0_72560900的博客
06-12 338
在linux(debian/ubuntu)中idea的插件默认安装位置和配置文件在哪里?
Linux Kernel入门到精通系列讲解（RV-Kernel 篇） 5.2 从零移植 Ubuntu，基于RISC-V
DSMGUOGUO的博客
06-10 160
之前，我们要知道几个概念，这样有助于后续移植。2. kernel和rootfs的调用关系。已经跑起来了，接下来我们就移植。3. 移植ubuntu。4. 运行ubuntu。6. 吐槽ubuntu。
linux高级环境编程 电子科技大学 线程池
12-01
Linux高级环境编程是电子科技大学...总之，通过学习Linux高级环境编程中的线程池技术，学生们可以提升自己的并发编程能力，深入了解操作系统和系统编程的原理和方法，为未来的软件开发和系统设计奠定坚实的技术基础。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值