线程池笔记

 为什么需要线程池？

1 某类任务特别耗时，严重影响该线程处理其他任务。 这类任务在其他线程异步执行

2 线程资源的开销与CPU核心之间做平衡选择（固定线程的数量，避免在任务到来的时候开启线程，任务结束的时候又销毁线程）

作用： 1复用线程资源，2充分利用系统资源。 3（异步执行耗时任务）

线程池是一个生产消费模型。

构成： 

1  生产者线程 ： 发布任务

2  任务队列 ：     

        任务 ， 任务的上下文，任务的执行函数。

3  线程池（消费者线程）：

         取出任务，执行任务，线程调度 mutex + condition（从无到有，从有到无）

4 平衡选择： 

        耗时任务：

                IO密集型  ： 2倍核心数+2    ， CPU密集型： 与CPU核心数相同

                确定线程池线程数量：  （IO等待时间+CPU运算时间）X 核心数 / CPU运算时间

问题1：多个线程同时在一个任务队列里面取任务

     任务队列就相当于这多个线程的临界资源，取任务的时候需要对任务队列进行加锁。

问题2：当任务不足的时候，线程的状态(如何休息) 

     条件变量(挂起) ---->进入条件等待，等待任务队列不为空的条件满足，然后唤醒线程。

实现一个线程池

1 创建线程池接口 

                线程的数量，队列的长度

2 销毁线程池的接口

                标记线程池退出，通知所有线程

3 生产者抛出任务的接口

                构造任务 ，放入任务队列  ， 通知线程唤醒

网络数据处理的阶段

1. 检测IO里面是否有数据(是否可读是否可写) IO事件是否就绪   EPOLL

2. 对IO进行读写操作。                                        RECV   \    SEND

3. 对数据进行解析。                                          parser解析

3种做法：

第一种：  单线程处理。

第二种：   可以把读写IO这两个任务抛到线程池里面。

第三种：   recv()之后，把解析完的(buffer)动作抛到线程池里面处理。

每一种各有优点和缺点

第一种： 如果在解析的过程当中引入了数据库的操作，整个过程会很慢。如果对于任务比较轻的纯内存操作式的，这种是OK的。

第二种： 针对于(fd)IO的操作时间比较长的，(比如说客户端的每一个fd设置成阻塞的IO)就可以采用这种方式。这种做法是三种做法里面速度最快的，不影响主循环。   但是，有一个很大的问题。     多个线程共用一个fd的现象  （客户端的发送请求间隔较短，服务端分配两个线程去处理同一个fd, 可能出现线程A在准备数据或者数据就绪的时候线程B已经把这个fd关闭了，还有可能AB两个线程同时发送，就会出现一些脏数据的现象。   

这三个步骤都可以分多线程进行。

 任务队列是两个东西，首先是任务，其次才是队列。   任务先描述清楚，这个队列就是一个集合。

怎么把任务一个一个封装比较好  (写日记，计算，crud）。 首先每一个任务都不一样，这里我们需要一个回调函数，这个回调函数是由任务自己本身去实现的。  第二还有一个参数，

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

#define LL_ADD(item, list) do { 	\
	item->prev = NULL;				\
	item->next = list;				\
	list = item;					\
} while(0)

#define LL_REMOVE(item, list) do {						\
	if (item->prev != NULL) item->prev->next = item->next;	\
	if (item->next != NULL) item->next->prev = item->prev;	\
	if (list == item) list = item->next;					\
	item->prev = item->next = NULL;							\
} while(0)


typedef struct NWORKER {
	pthread_t thread;
	int terminate;
	struct NWORKQUEUE *workqueue;
	struct NWORKER *prev;
	struct NWORKER *next;
} nWorker;

typedef struct NJOB {
	void (*job_function)(struct NJOB *job);
	void *user_data;
	struct NJOB *prev;
	struct NJOB *next;
} nJob;

typedef struct NWORKQUEUE {
	struct NWORKER *workers;
	struct NJOB *waiting_jobs;
	pthread_mutex_t jobs_mtx;
	pthread_cond_t jobs_cond;
} nWorkQueue;

typedef nWorkQueue nThreadPool;

static void *ntyWorkerThread(void *ptr) {
	nWorker *worker = (nWorker*)ptr;
	while (1) {
		pthread_mutex_lock(&worker->workqueue->jobs_mtx);
		while (worker->workqueue->waiting_jobs == NULL) {
			if (worker->terminate) break;
			pthread_cond_wait(&worker->workqueue->jobs_cond, &worker->workqueue->jobs_mtx);
		}
		if (worker->terminate) {
			pthread_mutex_unlock(&worker->workqueue->jobs_mtx);
			break;
		}
		nJob *job = worker->workqueue->waiting_jobs;
		if (job != NULL) {
			LL_REMOVE(job, worker->workqueue->waiting_jobs);
		}
		pthread_mutex_unlock(&worker->workqueue->jobs_mtx);

		if (job == NULL) continue;

		job->job_function(job);
	}
	free(worker);
	pthread_exit(NULL);
}



int ntyThreadPoolCreate(nThreadPool *workqueue, int numWorkers) {

	if (numWorkers < 1) numWorkers = 1;
	memset(workqueue, 0, sizeof(nThreadPool));
	pthread_cond_t blank_cond = PTHREAD_COND_INITIALIZER;
	memcpy(&workqueue->jobs_cond, &blank_cond, sizeof(workqueue->jobs_cond));
	pthread_mutex_t blank_mutex = PTHREAD_MUTEX_INITIALIZER;
	memcpy(&workqueue->jobs_mtx, &blank_mutex, sizeof(workqueue->jobs_mtx));
	int i = 0;
	for (i = 0;i < numWorkers;i ++) {
		nWorker *worker = (nWorker*)malloc(sizeof(nWorker));
		if (worker == NULL) {
			perror("malloc");
			return 1;
		}
		memset(worker, 0, sizeof(nWorker));
		worker->workqueue = workqueue;

		int ret = pthread_create(&worker->thread, NULL, ntyWorkerThread, (void *)worker);
		if (ret) {
			perror("pthread_create");
			free(worker);
			return 1;
		}
		LL_ADD(worker, worker->workqueue->workers);
	}
	return 0;
}


void ntyThreadPoolShutdown(nThreadPool *workqueue) {
	nWorker *worker = NULL;
	for (worker = workqueue->workers;worker != NULL;worker = worker->next) {
		worker->terminate = 1;
	}
	pthread_mutex_lock(&workqueue->jobs_mtx);
	workqueue->workers = NULL;
	workqueue->waiting_jobs = NULL;
	pthread_cond_broadcast(&workqueue->jobs_cond);
	pthread_mutex_unlock(&workqueue->jobs_mtx);
}

void ntyThreadPoolQueue(nThreadPool *workqueue, nJob *job) {
	pthread_mutex_lock(&workqueue->jobs_mtx);
	LL_ADD(job, workqueue->waiting_jobs);
	pthread_cond_signal(&workqueue->jobs_cond);
	pthread_mutex_unlock(&workqueue->jobs_mtx);
}

/************************** debug thread pool **************************/
//sdk  --> software develop kit
// 提供SDK给其他开发者使用
#if 1
#define KING_MAX_THREAD			80
#define KING_COUNTER_SIZE		1000

void king_counter(nJob *job) {
	int index = *(int*)job->user_data;
	printf("index : %d, selfid : %lu\n", index, pthread_self());
	free(job->user_data);
	free(job);
}

int main(int argc, char *argv[]) {
	nThreadPool pool;
	ntyThreadPoolCreate(&pool, KING_MAX_THREAD);
	int i = 0;
	for (i = 0;i < KING_COUNTER_SIZE;i ++) {
		nJob *job = (nJob*)malloc(sizeof(nJob));
		if (job == NULL) {
			perror("malloc");
			exit(1);
		}
		job->job_function = king_counter;
		job->user_data = malloc(sizeof(int));
		*(int*)job->user_data = i;
		ntyThreadPoolQueue(&pool, job);	
	}
	getchar();
	printf("\n");
}

#endif

1. 多线程共用fd，如何避免多线程使用的脏数据？
2. 线程池的放缩策略，如何做比较好？

nginx 中线程池

作用：处理文件缓冲；

开启线程池 

# 线程池默认关闭，configure 时，需要 --with-threads 来指定；

./configure --with-pcre-jit --with-http_ssl_module --with-http_realip_module --with-http_stub_status_module --with-http_v2_module -- with-threads

# 解决 gdb 远程权限的问题

echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope

# 创建名为 mark 的线程池

thread_pool mark threads=32 max_queue=65535;

location / {

root /img; aio threads=mark;

}

location / {

sendfile on; sendfile_max_chunk 128k; # 默认是没有限制的

}

location / {

directio 8m;

}

redis 中线程池

作用：读写 io 处理以及数据包解析、压缩；

redis当中的线程池，主线程既是生产者，也是消费者。且线程池的设计没有使用条件变量。主线程持有子线程的互斥锁，让子线程进入睡眠状态。

skynet 中线程池

作用：处理读写 io 、数据包解压缩、业务逻辑处理；特别地： 当同一个 io 在多个线程处理时，将写 io 转由网络线程处理；

 线程池作用阶段

reactor将消息事件放入全局队列，线程池去全局队列消费。