Penggunaan kumpulan benang di bawah Linux C

Adakah anda sering menghadapi masalah beban pelayan terlalu tinggi dan tidak boleh diakses seperti biasa? Kemudian, anda perlu memahami konsep yang sangat penting dalam kumpulan benang sistem Linux. Dengan mengkonfigurasi kumpulan benang dengan betul, anda boleh mengelakkan beban pelayan dengan berkesan dan meningkatkan kestabilan dan kebolehpercayaan sistem.

Kolam benang juga merupakan kaedah pemprosesan berbilang benang. Benang "pengeluar" mencadangkan tugasan dan menambahkannya pada "baris gilir tugas", dan kemudian beberapa utas secara automatik menyelesaikan tugasan pada "baris gilir tugas".

Pengaturcaraan berbilang benang, buat utas, nyatakan untuk menyelesaikan tugasan tertentu dan tunggu sehingga utas itu keluar. Walaupun ia boleh memenuhi keperluan pengaturcaraan, apabila kita perlu mencipta sejumlah besar benang, sejumlah besar CPU mungkin digunakan semasa penciptaan dan pemusnahan benang, menambah banyak overhed. Contohnya: salinan folder, respons daripada pelayan WEB.

Kolam benang digunakan untuk menyelesaikan masalah seperti ini, yang boleh mengurangkan overhed yang disebabkan oleh penciptaan dan pemusnahan benang yang kerap.

Idea teknologi kumpulan benang: Secara amnya, teknologi benang pra-dicipta digunakan, iaitu, sejumlah benang yang diperlukan dibuat lebih awal. Selepas utas ini dibuat terlebih dahulu, dengan mengandaikan tiada tugasan dalam "baris gilir tugas", maka biarkan utas ini tidur Setelah ada tugas, bangunkan utas untuk melaksanakan tugasan, tidak perlu untuk memusnahkan benang sehingga anda mahu Apabila keluar atau menutup, pada masa ini, anda memanggil fungsi yang memusnahkan kumpulan benang untuk memusnahkan benang.

Benang tidak akan dimusnahkan selepas menyelesaikan tugas, tetapi akan melaksanakan tugas seterusnya secara automatik. Selain itu, apabila terdapat banyak tugas, anda boleh mempunyai antara muka berfungsi untuk menambah bilangan utas Apabila terdapat sedikit tugas, anda boleh mempunyai antara muka berfungsi untuk memusnahkan beberapa utas.

Jika masa untuk mencipta dan memusnahkan benang boleh diabaikan berbanding dengan masa untuk melaksanakan tugasan, maka kita tidak perlu menggunakan kumpulan benang dalam kes ini.

"Baris gilir tugas" ialah sumber kongsi dengan "akses saling eksklusif"

Kolam benang pada asasnya ialah struktur data dan memerlukan struktur untuk menerangkannya:

struct pthread_pool //线程池的实现 
{ 
 //一般会有如下成员 
 
 //互斥锁，用来保护这个“任务队列” 
 pthread_mutex_t lock; //互斥锁  
  
 //线程条件变量 表示“任务队列”是否有任务 
 pthread_cond_t cond; //条件变量 
  
 bool shutdown; //表示是否退出程序 bool：类型 false / true 
 
 //任务队列(链表)，指向第一个需要指向的任务 
 //所有的线程都从任务链表中获取任务 "共享资源" 
 struct task * task_list; 
  
 //线程池中有多个线程，每一个线程都有tid, 需要一个数组去保存tid 
 pthread_t * tids; //malloc()  
  
 //线程池中正在服役的线程数，当前线程个数 
 unsigned int active_threads; 
  
 //线程池任务队列最大的任务数量 
 unsigned int max_waiting_tasks; 
  
 //线程池任务队列上当前有多少个任务 
 unsigned int cur_waiting_tasks; 
  
 //...... 
 
}; 
 
//任务队列(链表)上面的任务结点，只要能够描述好一个任务就可以了， 
//线程会不断地任务队列取任务 
struct task  //任务结点  
{ 
 // 1. 任务结点表示的任务，“函数指针”指向任务要执行的函数(cp_file) 
 void*(* do_task)(void * arg); 
  
 //2. 指针，指向任务指向函数的参数(文件描述符) 
 void * arg; 
  
 //3. 任务结点类型的指针，指向下一个任务 
 struct task * next; 
}; 

Kod rangka kerja kumpulan benang adalah seperti berikut, dan fungsinya diisi sendiri:

Antara muka fungsi diperlukan untuk mengendalikan kumpulan benang: pthread_pool.c, pthread_pool.h

Bayangkan "thread pool" sebagai syarikat penyumberan luar Apa yang anda perlu selesaikan ialah mengendalikan antara muka fungsi yang disediakan oleh kumpulan benang.

pthread_pool.c

#include "pthread_pool.h" 
 
/* 
 init_pool: 线程池初始化函数，初始化指定的线程池中有thread_num个初始线程 
 @pool：指针，指向您要初始化的那个线程池 
 @threa_num: 您要初始化的线程池中开始的线程数量 
 返回值：  
  成功 0 
  失败 -1 
*/ 
 
int init_pool(pthread_pool * pool , unsigned int threa_num) 
{ 
 //初始化线程池的结构体 
  
 //初始化线程互斥锁 
 pthread_mutex_init(&pool->lock, NULL); 
  
 //初始化线程条件变量 
 pthread_cond_init(&pool->cond, NULL); 
 
 pool->shutdown = false ;// 不退出 
 
 pool->task_list = (struct task*)malloc(sizeof(struct task)); 
 
 pool->tids = (pthread_t *)malloc(sizeof(pthread_t) * MAX_ACTIVE_THREADS); 
 if(pool->task_list == NULL || pool->tids == NULL) 
 { 
  perror("malloc memery error"); 
  return -1; 
 } 
 
 pool->task_list->next = NULL; 
 
 //线程池中一开始初始化多少个线程来服役 
 pool->active_threads = threa_num; 
 
 //表示线程池中最多有多少个任务 
 pool->max_waiting_tasks = MAX_WAITING_TASKS; 
 
 //线程池中任务队列当前的任务数量 
 pool->cur_waiting_tasks = 0; 
 
 //创建thread_num个线程，并且让线程去执行任务调配函数， 
 //记录所有线程的tid 
 int i = 0; 
 for(i = 0; i tids)[i], NULL, routine, (void*)pool); 
  if(ret != 0) 
  { 
   perror("create thread error"); 
   return -1; 
  } 
 
  printf("[%lu]:[%s] ===> tids[%d]:[%lu]",pthread_self(), 
   __FUNCTION__, i , pool->tids[i]); 
 } 
 
 return 0; 
} 
 
/* 
 routine: 任务调配函数。 
  所有线程开始都执行此函数，此函数会不断的从线程池的任务队列 
  中取下任务结点，去执行。 
   
  任务结点中包含“函数指针” h "函数参数" 
*/ 
 
void * routine(void * arg) 
{ 
 //arg表示你的线程池的指针 
  
 while() 
 { 
  //获取线程互斥锁，lock  
   
  //当线程池没有结束的时候，不断地从线程池的任务队列取下结点 
  //去执行。 
   
  //释放线程互斥锁，unlock 
   
  //释放任务结点 
 } 
} 
 
/* 
 destroy_pool: 销毁线程池，销毁前要保证所有的任务已经完成 
*/ 
 
int destroy_pool(pthread_pool * pool) 
{ 
 //释放所有空间 等待任务执行完毕(join)。 
 //唤醒所有线程 
 //利用join函数回收每一个线程资源。 
} 
 
/* 
 add_task：给任务队列增加任务， 把do_task指向的任务(函数指针)和 
  arg指向的参数保存到一个任务结点，添加到pool任务队列中。 
   
 @pool : 您要添加任务的线程池 
 @do_task ： 您需要添加的任务(cp_file) 
 @arg： 您要执行的任务的参数(文件描述符) 
*/ 
 
int add_task(pthread_pool *pool,void*(* do_task)(void * arg), void*arg) 
{ 
 //把第二个参数和第三个参数封装成struct task  
  
 //再把它添加到 pool->task 任务队列中去 
  
 //注意任务队列是一个共享资源 
  
 //假如任务后要唤醒等待的线程。 
} 
 
//如果任务多的时候，往线程池中添加线程  pthread_create 
int add_threads(pthread_pool * pool, unsigned int num); 
{ 
 //新创建num个线程，让每一个线程去执行线程调配函数 
  
 //将每一个新创建的线程tid，添加到pool-> tids  
} 
 
//如果任务少的时候，减少线程池中线程的数量 pthread_cancel join 
int remove_threads(pthread_pool * pool, unsigned int num) 
{ 
 //用pthread_cancel取消num个线程  
 //利用pthread_join函数去回收资源。 
} 

pthread_pool.h

#ifndef __PTHREAD_POOL_H__ 
#define __PTHREAD_POOL_H__ 
 
//表示线程池中最多有多少个线程 
#define MAX_ACTIVE_THREADS 20 
 
//表示线程池中最多有多少个任务 
#define MAX_WAITING_TASKS 1024 
 
//任务队列(链表)上面的任务结点，只要能够描述好一个任务就可以了， 
//线程会不断地任务队列取任务 
struct task  //任务结点  
{ 
 // 1. 任务结点表示的任务，“函数指针”指向任务要执行的函数(cp_file) 
 void*(* do_task)(void * arg); 
  
 //2. 指针，指向任务指向函数的参数(文件描述符) 
 void * arg; 
  
 //3. 任务结点类型的指针，指向下一个任务 
 struct task * next; 
}; 
 
struct pthread_pool //线程池的实现 
{ 
 //一般会有如下成员 
 
 //互斥锁，用来保护这个“任务队列” 
 pthread_mutex_t lock; //互斥锁  
  
 //线程条件变量 表示“任务队列”是否有任务 
 pthread_cond_t cond; //条件变量 
  
 bool shutdown; //表示是否退出程序 bool：类型 false / true 
 
 //任务队列(链表)，指向第一个需要指向的任务 
 //所有的线程都从任务链表中获取任务 "共享资源" 
 struct task * task_list; 
  
 //线程池中有多个线程，每一个线程都有tid, 需要一个数组去保存tid 
 pthread_t * tids; //malloc()  
  
 //线程池中正在服役的线程数，当前线程个数 
 unsigned int active_threads; 
  
 //线程池任务队列最大的任务数量 
 unsigned int max_waiting_tasks; 
  
 //线程池任务队列上当前有多少个任务 
 unsigned int cur_waiting_tasks; 
  
 //...... 
 
}; 
 
/* 
 init_pool: 线程池初始化函数，初始化指定的线程池中有thread_num 
  个初始线程 
 @pool：指针，指向您要初始化的那个线程池 
 @threa_num: 您要初始化的线程池中开始的线程数量 
 返回值：  
  成功 0 
  失败 -1 
*/ 
 
int init_pool(pthread_pool * pool , unsigned int threa_num); 
 
/* 
 routine: 任务调配函数。 
  所有线程开始都执行此函数，此函数会不断的从线程池的任务队列 
  中取下任务结点，去执行。 
   
  任务结点中包含“函数指针” h "函数参数" 
*/ 
 
void * routine(void * arg); 
 
/* 
 destroy_pool: 销毁线程池，销毁前要保证所有的任务已经完成 
*/ 
 
int destroy_pool(pthread_pool * pool); 
 
/* 
 add_task：给任务队列增加任务， 把do_task指向的任务(函数指针)和 
  arg指向的参数保存到一个任务结点，添加到pool任务队列中。 
   
 @pool : 您要添加任务的线程池 
 @do_task ： 您需要添加的任务(cp_file) 
 @arg： 您要执行的任务的参数(文件描述符) 
*/ 
 
int add_task(pthread_pool *pool,void*(* do_task)(void * arg), void*arg); 
 
//如果任务多的时候，往线程池中添加线程  pthread_create 
int add_threads(pthread_pool * pool, unsigned int num); 
 
 
//如果任务少的时候，减少线程池中线程的数量 pthread_cancel join 
int remove_threads(pthread_pool * pool, unsigned int num); 
 
#endif 

Atas ialah kandungan terperinci Penggunaan kumpulan benang di bawah Linux C. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!