用C语言调动英特尔显卡线程,C语言实现的线程池

概念：

如果一个程序每处理一个任务都需要创建一个线程来处理，假设创建线程的时间为T1，任务执行的时间为T2，线程销毁的时间为T3，那么线程的有效使用时间率为T2/(T1+T2+T3)，如果任务执行的时间非常短，那么线程的使用效率就会非常低，这对高并发的服务器性能来说是不能接受的，所以需要引入线程池概念。线程池简单点来说就是创建了很多工作线程，线程函数for(;;)循环，不停的从任务队伍获取任务并处理。

注意点：

1.线程同步问题，互斥锁，条件变量，信号量都可以用于线程同步，单纯的互斥锁只能轮询去处理数据，可能会空转进而造成CPU资源的浪费，信号量并不建议用(并发编程的十五条建议)，所以使用互斥锁+条件变量来解决线程同步的问题，可参考条件变量实现生产者消费者模型

线程池的组成：

1.任务队列：简单来说就是数据的容器，用来存放没有处理的任务，可以用队列，也可以用链表等数据结构

2.任务接口：具体点来说就是任务队列里面的数据要调用哪个函数来处理

3..线程管理：负责创建工作线程，销毁工作线程

----- gcc pthread_pool.c -lpthread -----

#include

#include

#include

#include

/* 任务,任务回调函数,任务队列 */

typedef struct worker {

void* (*callback) (void* arg); /*任务回调函数*/

void* arg; /*回调函数的参数*/

struct worker* next; /*任务队列链表*/

} CThread_worker;

/*回调函数*/

static void* callback(void* arg) {

printf("threadid:0x%x, working on task %d\n", pthread_self(), *(int*)arg);

sleep(1);

return(NULL);

}

/*线程池结构*/

typedef struct {

pthread_mutex_t mutex; /*互斥锁 */

pthread_cond_t cond; /*条件变量 */

CThread_worker* queue_head; /*线程池的任务队列*/

int shutdown; /*是否摧毁线程池 0:不摧毁 1:摧毁 */

pthread_t* threadid; /*线程ID数组*/

int max_thread_num; /*线程池最大线程数*/

int cur_queue_size; /*任务队列在任务数目*/

} CThread_pool;

/*线程函数*/

void* thread_routine(void* arg);

/*线程池实例*/

static CThread_pool* pool = NULL;

/*线程池初始化*/

void pool_init(int max_thread_num) {

/*一些列初始化*/

pool = (CThread_pool*) malloc(sizeof(CThread_pool));

pthread_mutex_init(&(pool->mutex), NULL);

pthread_cond_init(&(pool->cond), NULL);

pool->queue_head = NULL;

pool->shutdown = 0; /*0打开1关闭*/

pool->cur_queue_size = 0;

pool->threadid = (pthread_t*) malloc(max_thread_num * sizeof (pthread_t));

/*创建工作线程*/

int i = 0;

for (i=0; i

pthread_create(&(pool->threadid[i]), NULL, thread_routine, NULL);

}

}

/*将任务加入队列*/

int pool_add_worker(void* (*callback) (void* arg), void* arg) {

/*构造一个新任务*/

printf("pool add worker arg:%d\n", *(int*)arg);

CThread_worker* newworker = (CThread_worker*) malloc(sizeof(CThread_worker));

newworker->callback = callback;

newworker->arg = arg;

newworker->next = NULL; /*SET NULL*/

pthread_mutex_lock(&(pool->mutex));

/*将任务加入到任务队列中,也就是链表末端*/

CThread_worker* worker = pool->queue_head;

if (worker != NULL) {

while (worker->next != NULL)

worker = worker->next;

worker->next = newworker;

}

else {

pool->queue_head = newworker;

}

/*是否需要唤醒线程*/

int dosignal;

if (pool->cur_queue_size == 0)

dosignal = 1;

pool->cur_queue_size += 1; /*计数+1*/

pthread_mutex_unlock(&(pool->mutex));

/*需要叫醒工作线程*/

if (dosignal)

pthread_cond_signal(&(pool->cond));

return 0;

}

/*销毁线程池*/

int pool_destroy() {

printf("pool destroy now\n");

/*启用关闭开关*/

if (pool->shutdown)

return -1; /*防止两次调用*/

pool->shutdown = 1;

/*唤醒所有等待线程*/

pthread_cond_broadcast(&(pool->cond));

/*阻塞等待线程退出回收资源，还有另一种办法就是线程分离*/

int i;

for (i=0; imax_thread_num; ++i)

pthread_join(pool->threadid[i], NULL);

free(pool->threadid);

pool->threadid = NULL;

/*销毁任务队列*/

CThread_worker* head = NULL;

while (pool->queue_head != NULL) {

head = pool->queue_head;

pool->queue_head = pool->queue_head->next;

free(head);

head = NULL;

}

/*销毁互斥锁与条件变量*/

pthread_mutex_destroy(&(pool->mutex));

pthread_cond_destroy(&(pool->cond));

free(pool);

pool = NULL;

printf("pool destroy end\n");

return 0;

}

/*工作线程函数*/

void* thread_routine(void* arg) {

printf("starting threadid:0x%x\n", pthread_self());

for (; ;) {

pthread_mutex_lock(&(pool->mutex));

/*任务队列为空时wait唤醒,当销毁线程池时跳出循环*/

while (pool->cur_queue_size == 0 && !pool->shutdown) {

printf("threadid:0x%x is waiting\n", pthread_self());

pthread_cond_wait(&(pool->cond), &(pool->mutex));

}

/*线程池要销毁了*/

if (pool->shutdown) {

pthread_mutex_unlock(&(pool->mutex));

printf("threadid:0x%x will exit\n", pthread_self());

pthread_exit(NULL);

}

/*开始执行任务*/

printf("threadid:0x%x is starting to work\n", pthread_self());

/*等待队列长度减去1，并取出链表中的头元素*/

pool->cur_queue_size -= 1;

CThread_worker* worker = pool->queue_head;

pool->queue_head = worker->next;

pthread_mutex_unlock(&(pool->mutex));

/*调用回调函数，执行任务*/

(*(worker->callback)) (worker->arg);

free(worker);

worker = NULL;

}

return(NULL);

}

/*测试*/

int main(int argc, char const *argv[])

{

pool_init(2); /*创建n个线程*/

/*添加n个任务*/

int* workingnum = (int*) malloc(sizeof(int) * 10); /* 一定要动态创建 */

int i;

for (i=0; i<5; ++i) {

workingnum[i] = i;

pool_add_worker(callback, &workingnum[i]);

}

sleep(5); /*等待所有任务完成*/

pool_destroy(); /*销毁线程池*/

free(workingnum);

workingnum = NULL;

return 0;

}

测试结果：