线程池的设计与测试

最新推荐文章于 2023-08-22 15:46:49 发布
最新推荐文章于 2023-08-22 15:46:49 发布
阅读量347 收藏
点赞数
分类专栏： Linux C/C++

编写了一个最基本的线程池类，处理用c_work表示的工作任务。C++还很不熟练，欢迎会C++的提出宝贵的修改意见。

程序有注释，所以应该很好读懂。测试程序在下面。




[cpp]  view plain copy print ?
  1. ///  
  2. //线程池类   
  3. ///  
  4. #include <pthread.h>  
  5. #include <stdlib.h>  
  6. #include <stdio.h>  
  7. #include <unistd.h>  
  8. #include <assert.h>  
  9.   
  10. const int DEFAULT_MAX_THREAD_NUM = 10;  
  11. const int MAX_WORK_NUM = 100000;  
  12. //c_worker类  
  13. class c_work  
  14. {  
  15.     public:  
  16.         c_work():process(NULL), arg(NULL), next(NULL){}  
  17.         c_work(void *(*prcss)(void *), void *arg):  
  18.             process(prcss), arg(arg), next(NULL) {}  
  19.         ~c_work();   
  20.   
  21.         void *(*process)(void *);  
  22.         void *arg;  
  23.         unsigned char type; //最高位表示arg是否需要delete操作  
  24.         c_work *next;  
  25. };  
  26.   
  27. c_work::~c_work()  
  28. {  
  29.     unsigned char ifdel = type >> 7;  
  30.     if (ifdel)  
  31.     {  
  32.         delete arg;  
  33.         arg = NULL;  
  34.     }  
  35. }  
  36.   
  37. class c_thread_pool  
  38. {  
  39.     public:  
  40.         c_thread_pool();  
  41.         c_thread_pool(const int max_thread_num);  
  42.         ~c_thread_pool();  
  43.   
  44.         int add_work(c_work work);  
  45.         static void *thread_routine(void *arg);  
  46.   
  47.         pthread_mutex_t queue_lock;  
  48.         pthread_cond_t queue_cond;  
  49.   
  50. //  private:  
  51.         c_work *queue_head;  
  52.         c_work *queue_tail;  
  53.         int shutdown;  
  54.   
  55.         pthread_t *threadid;  
  56.         int max_thread_num;  
  57.         int cur_queue_size;  
  58. };  
  59.   
  60. c_thread_pool::c_thread_pool()  
  61. {  
  62.   
  63.     pthread_mutex_init(&queue_lock, NULL);  
  64.     pthread_cond_init(&queue_cond, NULL);  
  65.   
  66.     //工作队列初始化  
  67.     queue_head = NULL;  
  68.     queue_tail = NULL;  
  69.       
  70.     max_thread_num = max_thread_num;  
  71.     cur_queue_size = 0;  
  72.   
  73.     shutdown = 0;  
  74.   
  75.     max_thread_num = DEFAULT_MAX_THREAD_NUM;  
  76.     threadid = new pthread_t[max_thread_num];  
  77.     int i = 0;  
  78.   
  79.     for (i = 0; i < max_thread_num; i++)  
  80.     {  
  81.         pthread_create(&(threadid[i]), NULL, thread_routine, (void*)this);  
  82.     }  
  83. }  
  84.   
  85.   
  86. c_thread_pool::c_thread_pool(int max_thread_num)  
  87. {  
  88.   
  89.     pthread_mutex_init(&queue_lock, NULL);  
  90.     pthread_cond_init(&queue_cond, NULL);  
  91.   
  92.     //工作队列初始化  
  93.     queue_head = NULL;  
  94.     queue_tail = NULL;  
  95.       
  96.     max_thread_num = max_thread_num;  
  97.     cur_queue_size = 0;  
  98.   
  99.     threadid = new pthread_t[max_thread_num];  
  100.     int i = 0;  
  101.     for (i = 0; i < max_thread_num; i++)  
  102.     {  
  103.         pthread_create(&(threadid[i]), NULL, thread_routine, (void*)this);  
  104.     }  
  105. }  
  106.   
  107. /*向线程池中的任务队列加入任务*/  
  108. int c_thread_pool::add_work(c_work work)  
  109. {  
  110.     c_work *newwork = new c_work;  
  111.     newwork->process = work.process;  
  112.     newwork->arg = work.arg;  
  113.     newwork->next = NULL;  
  114.   
  115.     pthread_mutex_lock(&queue_lock);  
  116.       
  117.     /*将任务加入到等待队列中*/  
  118.     if (queue_head != NULL && queue_tail != NULL)  
  119.     {  
  120.         queue_tail->next = newwork;  
  121.         queue_tail = newwork;     
  122.     }  
  123.     else  
  124.     {  
  125.         //空队列  
  126.         queue_head = newwork;  
  127.         queue_tail = newwork;  
  128.     }  
  129.   
  130.     cur_queue_size++;  
  131.     pthread_mutex_unlock(&queue_lock);  
  132.     /*等待队列中有任务了，唤醒一个等待线程,注意如果所有线程都在忙碌，这句没有任何作用*/  
  133.     pthread_cond_signal(&(queue_cond));   
  134.     printf("add work returned!\n");  
  135.     return 0;  
  136. }  
  137.   
  138.   
  139. void* c_thread_pool::thread_routine(void *arg)  
  140. {  
  141.     c_thread_pool *pool = (c_thread_pool *)arg;  
  142.     int i = 0;  
  143.     while (1)  
  144.     {  
  145.         pthread_mutex_lock(&(pool->queue_lock));  
  146.         //如果等待队列为0并且不销毁线程池，则处于阻塞状态; 注意  
  147.          // pthread_cond_wait是一个原子操作，等待前会解锁，唤醒后会加锁  
  148.   
  149.         //标注：注意这一如果任务队列不为空的话，while语句将被跳过，直接执行下面的调用。  
  150.         while (pool->cur_queue_size == 0 && pool->shutdown)  
  151.         {  
  152.             pthread_cond_wait(&(pool->queue_cond), &(pool->queue_lock));  
  153.         }  
  154.   
  155.   
  156.         //等待队列长度减去1，并取出链表中的头元素  
  157.         if (pool->cur_queue_size > 0 && pool->queue_head != NULL)  
  158.         {  
  159.             printf("IN THREAD ROUTINE size = %d && queue head is not NULL\n", pool->cur_queue_size);  
  160.             pool->cur_queue_size--;  
  161.             c_work *work = pool->queue_head;  
  162.             pool->queue_head = work->next;  
  163.             pthread_mutex_unlock(&(pool->queue_lock));  
  164.   
  165.             //调用回调函数，执行测试任务  
  166.             //  
  167.             (*(work->process))(work->arg);  
  168.             free(work);  
  169.             work = NULL;  
  170.         }  
  171.         else //不可达  
  172.         {  
  173.             pthread_mutex_unlock(&(pool->queue_lock));  
  174.         }  
  175.     }  
  176.       
  177. }  
  178.   
  179. c_thread_pool::~c_thread_pool()  
  180. {  
  181.     for (int i = 0; i < max_thread_num; ++i)   
  182.         pthread_cancel(threadid[i]);  
  183.     for (c_work *w_t = queue_head; w_t != NULL;)  
  184.     {  
  185.         c_work *temp = w_t->next;  
  186.         delete w_t;  
  187.         w_t = temp;  
  188.     }  
  189.     delete [] threadid;  
  190. }  



[cpp]  view plain copy print ?
  1. ///  
  2. //线程池类   
  3. ///  
  4. #include <pthread.h>  
  5. #include <stdlib.h>  
  6. #include <stdio.h>  
  7. #include <unistd.h>  
  8. #include <assert.h>  
  9.   
  10. const int DEFAULT_MAX_THREAD_NUM = 10;  
  11. const int MAX_WORK_NUM = 100000;  
  12. //c_worker类  
  13. class c_work  
  14. {  
  15.     public:  
  16.         c_work():process(NULL), arg(NULL), next(NULL){}  
  17.         c_work(void *(*prcss)(void *), void *arg):  
  18.             process(prcss), arg(arg), next(NULL) {}  
  19.         ~c_work();   
  20.   
  21.         void *(*process)(void *);  
  22.         void *arg;  
  23.         unsigned char type; //最高位表示arg是否需要delete操作  
  24.         c_work *next;  
  25. };  
  26.   
  27. c_work::~c_work()  
  28. {  
  29.     unsigned char ifdel = type >> 7;  
  30.     if (ifdel)  
  31.     {  
  32.         delete arg;  
  33.         arg = NULL;  
  34.     }  
  35. }  
  36.   
  37. class c_thread_pool  
  38. {  
  39.     public:  
  40.         c_thread_pool();  
  41.         c_thread_pool(const int max_thread_num);  
  42.         ~c_thread_pool();  
  43.   
  44.         int add_work(c_work work);  
  45.         static void *thread_routine(void *arg);  
  46.   
  47.         pthread_mutex_t queue_lock;  
  48.         pthread_cond_t queue_cond;  
  49.   
  50. //  private:  
  51.         c_work *queue_head;  
  52.         c_work *queue_tail;  
  53.         int shutdown;  
  54.   
  55.         pthread_t *threadid;  
  56.         int max_thread_num;  
  57.         int cur_queue_size;  
  58. };  
  59.   
  60. c_thread_pool::c_thread_pool()  
  61. {  
  62.   
  63.     pthread_mutex_init(&queue_lock, NULL);  
  64.     pthread_cond_init(&queue_cond, NULL);  
  65.   
  66.     //工作队列初始化  
  67.     queue_head = NULL;  
  68.     queue_tail = NULL;  
  69.       
  70.     max_thread_num = max_thread_num;  
  71.     cur_queue_size = 0;  
  72.   
  73.     shutdown = 0;  
  74.   
  75.     max_thread_num = DEFAULT_MAX_THREAD_NUM;  
  76.     threadid = new pthread_t[max_thread_num];  
  77.     int i = 0;  
  78.   
  79.     for (i = 0; i < max_thread_num; i++)  
  80.     {  
  81.         pthread_create(&(threadid[i]), NULL, thread_routine, (void*)this);  
  82.     }  
  83. }  
  84.   
  85.   
  86. c_thread_pool::c_thread_pool(int max_thread_num)  
  87. {  
  88.   
  89.     pthread_mutex_init(&queue_lock, NULL);  
  90.     pthread_cond_init(&queue_cond, NULL);  
  91.   
  92.     //工作队列初始化  
  93.     queue_head = NULL;  
  94.     queue_tail = NULL;  
  95.       
  96.     max_thread_num = max_thread_num;  
  97.     cur_queue_size = 0;  
  98.   
  99.     threadid = new pthread_t[max_thread_num];  
  100.     int i = 0;  
  101.     for (i = 0; i < max_thread_num; i++)  
  102.     {  
  103.         pthread_create(&(threadid[i]), NULL, thread_routine, (void*)this);  
  104.     }  
  105. }  
  106.   
  107. /*向线程池中的任务队列加入任务*/  
  108. int c_thread_pool::add_work(c_work work)  
  109. {  
  110.     c_work *newwork = new c_work;  
  111.     newwork->process = work.process;  
  112.     newwork->arg = work.arg;  
  113.     newwork->next = NULL;  
  114.   
  115.     pthread_mutex_lock(&queue_lock);  
  116.       
  117.     /*将任务加入到等待队列中*/  
  118.     if (queue_head != NULL && queue_tail != NULL)  
  119.     {  
  120.         queue_tail->next = newwork;  
  121.         queue_tail = newwork;     
  122.     }  
  123.     else  
  124.     {  
  125.         //空队列  
  126.         queue_head = newwork;  
  127.         queue_tail = newwork;  
  128.     }  
  129.   
  130.     cur_queue_size++;  
  131.     pthread_mutex_unlock(&queue_lock);  
  132.     /*等待队列中有任务了，唤醒一个等待线程,注意如果所有线程都在忙碌，这句没有任何作用*/  
  133.     pthread_cond_signal(&(queue_cond));   
  134.     printf("add work returned!\n");  
  135.     return 0;  
  136. }  
  137.   
  138.   
  139. void* c_thread_pool::thread_routine(void *arg)  
  140. {  
  141.     c_thread_pool *pool = (c_thread_pool *)arg;  
  142.     int i = 0;  
  143.     while (1)  
  144.     {  
  145.         pthread_mutex_lock(&(pool->queue_lock));  
  146.         //如果等待队列为0并且不销毁线程池，则处于阻塞状态; 注意  
  147.          // pthread_cond_wait是一个原子操作，等待前会解锁，唤醒后会加锁  
  148.   
  149.         //标注：注意这一如果任务队列不为空的话，while语句将被跳过，直接执行下面的调用。  
  150.         while (pool->cur_queue_size == 0 && pool->shutdown)  
  151.         {  
  152.             pthread_cond_wait(&(pool->queue_cond), &(pool->queue_lock));  
  153.         }  
  154.   
  155.   
  156.         //等待队列长度减去1，并取出链表中的头元素  
  157.         if (pool->cur_queue_size > 0 && pool->queue_head != NULL)  
  158.         {  
  159.             printf("IN THREAD ROUTINE size = %d && queue head is not NULL\n", pool->cur_queue_size);  
  160.             pool->cur_queue_size--;  
  161.             c_work *work = pool->queue_head;  
  162.             pool->queue_head = work->next;  
  163.             pthread_mutex_unlock(&(pool->queue_lock));  
  164.   
  165.             //调用回调函数，执行测试任务  
  166.             //  
  167.             (*(work->process))(work->arg);  
  168.             free(work);  
  169.             work = NULL;  
  170.         }  
  171.         else //不可达  
  172.         {  
  173.             pthread_mutex_unlock(&(pool->queue_lock));  
  174.         }  
  175.     }  
  176.       
  177. }  
  178.   
  179. c_thread_pool::~c_thread_pool()  
  180. {  
  181.     for (int i = 0; i < max_thread_num; ++i)   
  182.         pthread_cancel(threadid[i]);  
  183.     for (c_work *w_t = queue_head; w_t != NULL;)  
  184.     {  
  185.         c_work *temp = w_t->next;  
  186.         delete w_t;  
  187.         w_t = temp;  
  188.     }  
  189.     delete [] threadid;  
  190. }  

[cpp]  view plain copy print ?
  1. #include "___pool.h"  
  2.   
  3. struct adder  
  4. {  
  5.     int a;  
  6.     int b;  
  7. };  
  8.   
  9. void *process(void *add)  
  10. {  
  11.     struct adder *addp = (struct adder*)add;  
  12.     printf("-----in process:\n");  
  13.     printf("sum = %d + %d = %d\n", addp->a, addp->b, addp->a +  addp->b);  
  14.     return (void *)0;  
  15. }  
  16. int main(int argc, char **argv)  
  17. {  
  18.     if (argc < 2)  
  19.     {     
  20.         printf("input task num!\n");  
  21.         return -1;  
  22.     }  
  23.     int num = atoi(argv[1]);  
  24.     int i;  
  25.     c_thread_pool pool(10);           
  26.     struct adder add[num];  
  27.     for (i = 0; i < num; i++)  
  28.     {  
  29.         add[i].a = i + 1;  
  30.         add[i].b = i + 1;  
  31.     }  
  32.     c_worker wker[num];  
  33.     for (i = 0; i < num; i++)  
  34.     {  
  35.         wker[i].process = process;  
  36.         wker[i].arg = &add[i];  
  37.     }  
  38.     for (i = 0; i < num; i++)  
  39.     {  
  40.         pool.add_worker(wker[i]);  
  41.     }  
  42.     sleep(100);  
  43.     printf("\n");  
  44.     return 0;  
  45. }  


原文地址：http://blog.csdn.net/naturebe/article/details/7901130

[cpp]  view plain copy print ?
  1. ///  
  2. //线程池类   
  3. ///  
  4. #include <pthread.h>  
  5. #include <stdlib.h>  
  6. #include <stdio.h>  
  7. #include <unistd.h>  
  8. #include <assert.h>  
  9.   
  10. const int DEFAULT_MAX_THREAD_NUM = 10;  
  11. const int MAX_WORK_NUM = 100000;  
  12. //c_worker类  
  13. class c_work  
  14. {  
  15.     public:  
  16.         c_work():process(NULL), arg(NULL), next(NULL){}  
  17.         c_work(void *(*prcss)(void *), void *arg):  
  18.             process(prcss), arg(arg), next(NULL) {}  
  19.         ~c_work();   
  20.   
  21.         void *(*process)(void *);  
  22.         void *arg;  
  23.         unsigned char type; //最高位表示arg是否需要delete操作  
  24.         c_work *next;  
  25. };  
  26.   
  27. c_work::~c_work()  
  28. {  
  29.     unsigned char ifdel = type >> 7;  
  30.     if (ifdel)  
  31.     {  
  32.         delete arg;  
  33.         arg = NULL;  
  34.     }  
  35. }  
  36.   
  37. class c_thread_pool  
  38. {  
  39.     public:  
  40.         c_thread_pool();  
  41.         c_thread_pool(const int max_thread_num);  
  42.         ~c_thread_pool();  
  43.   
  44.         int add_work(c_work work);  
  45.         static void *thread_routine(void *arg);  
  46.   
  47.         pthread_mutex_t queue_lock;  
  48.         pthread_cond_t queue_cond;  
  49.   
  50. //  private:  
  51.         c_work *queue_head;  
  52.         c_work *queue_tail;  
  53.         int shutdown;  
  54.   
  55.         pthread_t *threadid;  
  56.         int max_thread_num;  
  57.         int cur_queue_size;  
  58. };  
  59.   
  60. c_thread_pool::c_thread_pool()  
  61. {  
  62.   
  63.     pthread_mutex_init(&queue_lock, NULL);  
  64.     pthread_cond_init(&queue_cond, NULL);  
  65.   
  66.     //工作队列初始化  
  67.     queue_head = NULL;  
  68.     queue_tail = NULL;  
  69.       
  70.     max_thread_num = max_thread_num;  
  71.     cur_queue_size = 0;  
  72.   
  73.     shutdown = 0;  
  74.   
  75.     max_thread_num = DEFAULT_MAX_THREAD_NUM;  
  76.     threadid = new pthread_t[max_thread_num];  
  77.     int i = 0;  
  78.   
  79.     for (i = 0; i < max_thread_num; i++)  
  80.     {  
  81.         pthread_create(&(threadid[i]), NULL, thread_routine, (void*)this);  
  82.     }  
  83. }  
  84.   
  85.   
  86. c_thread_pool::c_thread_pool(int max_thread_num)  
  87. {  
  88.   
  89.     pthread_mutex_init(&queue_lock, NULL);  
  90.     pthread_cond_init(&queue_cond, NULL);  
  91.   
  92.     //工作队列初始化  
  93.     queue_head = NULL;  
  94.     queue_tail = NULL;  
  95.       
  96.     max_thread_num = max_thread_num;  
  97.     cur_queue_size = 0;  
  98.   
  99.     threadid = new pthread_t[max_thread_num];  
  100.     int i = 0;  
  101.     for (i = 0; i < max_thread_num; i++)  
  102.     {  
  103.         pthread_create(&(threadid[i]), NULL, thread_routine, (void*)this);  
  104.     }  
  105. }  
  106.   
  107. /*向线程池中的任务队列加入任务*/  
  108. int c_thread_pool::add_work(c_work work)  
  109. {  
  110.     c_work *newwork = new c_work;  
  111.     newwork->process = work.process;  
  112.     newwork->arg = work.arg;  
  113.     newwork->next = NULL;  
  114.   
  115.     pthread_mutex_lock(&queue_lock);  
  116.       
  117.     /*将任务加入到等待队列中*/  
  118.     if (queue_head != NULL && queue_tail != NULL)  
  119.     {  
  120.         queue_tail->next = newwork;  
  121.         queue_tail = newwork;     
  122.     }  
  123.     else  
  124.     {  
  125.         //空队列  
  126.         queue_head = newwork;  
  127.         queue_tail = newwork;  
  128.     }  
  129.   
  130.     cur_queue_size++;  
  131.     pthread_mutex_unlock(&queue_lock);  
  132.     /*等待队列中有任务了，唤醒一个等待线程,注意如果所有线程都在忙碌，这句没有任何作用*/  
  133.     pthread_cond_signal(&(queue_cond));   
  134.     printf("add work returned!\n");  
  135.     return 0;  
  136. }  
  137.   
  138.   
  139. void* c_thread_pool::thread_routine(void *arg)  
  140. {  
  141.     c_thread_pool *pool = (c_thread_pool *)arg;  
  142.     int i = 0;  
  143.     while (1)  
  144.     {  
  145.         pthread_mutex_lock(&(pool->queue_lock));  
  146.         //如果等待队列为0并且不销毁线程池，则处于阻塞状态; 注意  
  147.          // pthread_cond_wait是一个原子操作，等待前会解锁，唤醒后会加锁  
  148.   
  149.         //标注：注意这一如果任务队列不为空的话，while语句将被跳过，直接执行下面的调用。  
  150.         while (pool->cur_queue_size == 0 && pool->shutdown)  
  151.         {  
  152.             pthread_cond_wait(&(pool->queue_cond), &(pool->queue_lock));  
  153.         }  
  154.   
  155.   
  156.         //等待队列长度减去1，并取出链表中的头元素  
  157.         if (pool->cur_queue_size > 0 && pool->queue_head != NULL)  
  158.         {  
  159.             printf("IN THREAD ROUTINE size = %d && queue head is not NULL\n", pool->cur_queue_size);  
  160.             pool->cur_queue_size--;  
  161.             c_work *work = pool->queue_head;  
  162.             pool->queue_head = work->next;  
  163.             pthread_mutex_unlock(&(pool->queue_lock));  
  164.   
  165.             //调用回调函数，执行测试任务  
  166.             //  
  167.             (*(work->process))(work->arg);  
  168.             free(work);  
  169.             work = NULL;  
  170.         }  
  171.         else //不可达  
  172.         {  
  173.             pthread_mutex_unlock(&(pool->queue_lock));  
  174.         }  
  175.     }  
  176.       
  177. }  
  178.   
  179. c_thread_pool::~c_thread_pool()  
  180. {  
  181.     for (int i = 0; i < max_thread_num; ++i)   
  182.         pthread_cancel(threadid[i]);  
  183.     for (c_work *w_t = queue_head; w_t != NULL;)  
  184.     {  
  185.         c_work *temp = w_t->next;  
  186.         delete w_t;  
  187.         w_t = temp;  
  188.     }  
  189.     delete [] threadid;  
  190. }  
JimmySun_QC
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程池并发测试例子
12-19
java代码 ThreadPoolExecutor线程池并发测试例子如有误欢迎指正
C++ 线程池设计
08-22
5. **线程池扩展与收缩**：根据任务负载动态调整线程数量是线程池的一个重要特性。当任务减少时，线程池可能会销毁一些线程以节省资源；反之，当任务增加时，线程池会创建新的线程以满足需求。 6. **线程池销毁**：...
全网最详细，性能测试-连接池与线程详解，8年测试总结...
大佬云集技术答疑交流群：743262921(进群暗号:222)
06-12 890
连接池1、什么是连接池？我们为什么需要它？连接池允许多个客户端使用缓存起来的连接对象，这些对象可以连接数据库，它们是共享的、可被重复使用的。打开/关闭数据库连接开销很大，连接池技术允许我们在连接池里维护连接对象，这样可以提高数据库的执行命令的性能。多个客户端请求可以重复使用相同的连接对象，当每次收到一个客户端请求时，就会搜索连接池，看看有没有闲置连接对象。如果没有，要么所有的客户端请求都进入队列排队，要么在池中创建一个新的连接对象（这取决于池里已有多少个连接存在以及配置支持多少连接）。
使用线程池 插入万条数据做压力测试
qq_53170175的博客
08-22 212
往数据库插入一万条数据多线程
手写线程池实例并测试
热门推荐
小威的博客
02-22 3万+
在之前的文章中介绍过线程池的核心原理，在一次面试中面试官让手写线程池，这块知识忘记的差不多了，因此本篇文章做一个回顾。
线程池设计
02-12
线程池设计是一种高效利用系统资源，优化多线程应用执行效率的方法。在现代操作系统中，创建和销毁线程都伴随着一定的开销，包括内存分配、上下文切换等。线程池通过预先创建并维护一组可重用线程，来减少这种开销，...
NetsuiteExamples1.04Beta 含WebSocketServe 应用测试，单线程，线程池
最新发布
09-14
NetsuiteExamples1.04Beta 是一个软件开发项目，主要关注的是WebSocket服务的应用与测试。WebSocket协议是一种在客户端和服务器之间实现全双工通信的协议，它允许数据双向实时传输，极大地提高了网络应用的交互性。...
Java8并行流中自定义线程池操作示例
08-26
《Java进程与线程操作技巧总结》、《Java数据结构与算法教程》、《Java操作DOM节点技巧总结》、《Java文件与目录操作技巧汇总》和《Java缓存操作技巧汇总》希望本文所述对大家java程序设计有所帮助。
线程池创建及测试
03-31
在linux下运行的线程，学习线程和测试线程，以及创建线程池的开发贷代码，可以直接运行。
小测试-线程池
mantou0611的专栏
04-09 544
参考：《Java 网络编程》。 有很多数据结构可以作为池，不过队列可能是确保任务以先进先出顺序来执行的最有效的一种数据结构。但是，不管哪种数据结构实现池，都必须要非常注意同步的问题。 因为会有很多线程同时与之交互。避免这个问题最简单的方式就是使用java.util.Vector或者Java集合中API中的同步Collection。ArrayList：List list = Collection
测试线程池
啊猿的博客
03-28 135
测试线程池 package gaoji; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; //测试线程池 public class Testpool { public static void main(String[] args) { //1、创建服务，创建线程池 //newFixedThreadPool参数为：线程池大小 Exe
线程池性能测试
独孤过的博客
05-15 2005
Eterfree线程池以一个基于Boost程序库的线程池为参照线程池，分别在不同硬件、不同操作系统的计算机对两种线程池进行性能测试。 最近一次以Visual Studio 2019编译x64 Release版本的测试程序，一共进行10次测试，每次测试以100个线程执行300000个相同任务。记录线程池执行的任务数和所用时间，计算每毫秒执行的任务数，最终取执行任务的平均速度。
线程池测试
flower_CSDN的博客
07-14 449
线程池如果不关闭，则主线程无法终止，因为线程池中的核心线程永远不会被回收，除非关闭线程池，或者应用程序终止。 ThreadFactory中可以将线程设置为守护线程，主线程可以正常执行并结束退出，但是主线程运行结束子线程还没有运行结束。所以还是需要关闭线程池。等线程池中的任务都运行完之后再执行主线程的内容。 import java.io.BufferedReader; import java.io.File; import java.io.FileReader; import java.util.concur
c线程池有完整测试案例三
jiletianzun的博客
04-27 149
threadpool.c #include"threadpool.h" //线程池创建 int createThreadPool(ThreadPool*pool,int min,int max,int queueMaxNum) { int iserror=0; //标记，用来接收错误标记 do{ //线程池空间开辟 if(pool == NULL) { //pool=(ThreadPool*)malloc
java线程池测试
wec153452679的专栏
11-25 431
package com.company; import java.util.concurrent.*; public class 线程池 { public static void main(String[] args) { long start = System.currentTimeMillis(); ExecutorService executor = Executors.newFixedThreadPool(1000); for (int.
线程池的测试总结(ThreadPoolExecutor)
大诚子的博客
07-09 3299
废话不多说,线上代码再做总结....package test; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.BlockingQueue; import java.util.concurrent.LinkedBlockingQueue; import java.util.concurrent...
5种方法，教你判断线程池是否全部完成
Java笔记虾
05-23 5079
点击关注公众号，利用碎片时间学习概述最近写小玩具的时候用到了CountDownLatch计数器，然后顺便想了想判断线程池全部结束有多少种方法。在网上搜了下，可能有些没找到，但是我找到的有（所有方法都是在ThreadPoolExecutor线程池方法下测试的）：isTerminated()判断方式，在执行shutdown()，关闭线程池后，判断是否所有任务已经...
测试线程池（Java）
...
06-11 157
测试线程池（Java） package src.thread; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class TestPool { public static void main(String[] args) { //1.创建服务，创建线程池 //newFixedThreadPool 参数为线程池的大小
使用C++设计一个线程池
05-27
线程池是一种常见的并发编程模型，它可以减少线程的创建和销毁带来的开销，提高多线程程序的性能和稳定性。下面是一个简单的C++线程池实现，仅供参考： ```c++ #include <iostream> #include <vector> #include <queue> #include <thread> #include <mutex> #include <condition_variable> #include <functional> #include <future> class ThreadPool { public: ThreadPool(size_t thread_count) : stop(false) { for (size_t i = 0; i < thread_count; ++i) { workers.emplace_back( [this] { for (;;) { std::function<void()> task; { std::unique_lock<std::mutex> lock(this->queue_mutex); this->condition.wait(lock, [this] { return this->stop || !this->tasks.empty(); }); if (this->stop && this->tasks.empty()) return; task = std::move(this->tasks.front()); this->tasks.pop(); } task(); } } ); } } template<class F, class... Args> auto enqueue(F&& f, Args&&... args) -> std::future<typename std::result_of<F(Args...)>::type> { using return_type = typename std::result_of<F(Args...)>::type; auto task = std::make_shared< std::packaged_task<return_type()> >( std::bind(std::forward<F>(f), std::forward<Args>(args)...) ); std::future<return_type> res = task->get_future(); { std::unique_lock<std::mutex> lock(queue_mutex); // 不允许向已停止的线程池中添加新的任务 if (stop) throw std::runtime_error("enqueue on stopped ThreadPool"); tasks.emplace([task]() { (*task)(); }); } condition.notify_one(); return res; } ~ThreadPool() { { std::unique_lock<std::mutex> lock(queue_mutex); stop = true; } condition.notify_all(); for (std::thread& worker : workers) worker.join(); } private: std::vector<std::thread> workers; std::queue<std::function<void()>> tasks; std::mutex queue_mutex; std::condition_variable condition; bool stop; }; ``` 上面的代码中，`ThreadPool`类封装了一个线程池，提供了`enqueue()`方法用于向线程池中添加任务。当调用`enqueue()`方法时，线程池会将任务封装成一个`std::packaged_task`对象，并将其放入任务队列中。工作线程会从任务队列中取出任务并执行，直到线程池被销毁或者调用`stop()`方法停止线程池。 可以使用下面的代码测试线程池的功能： ```c++ #include <chrono> #include <random> int main() { ThreadPool pool(4); std::vector<std::future<int>> results; std::random_device rd; std::mt19937 gen(rd()); std::uniform_int_distribution<> dis(1, 100); for (int i = 0; i < 8; ++i) { results.emplace_back( pool.enqueue([i, dis, &gen] { std::cout << "task " << i << " start" << std::endl; std::this_thread::sleep_for(std::chrono::seconds(dis(gen))); std::cout << "task " << i << " end" << std::endl; return i * i; }) ); } for (auto&& result : results) std::cout << result.get() << ' '; std::cout << std::endl; return 0; } ``` 上面的代码创建了一个包含4个线程的线程池，并向线程池中添加了8个任务。每个任务会随机休眠1~100秒的时间，然后返回任务编号的平方。最后打印所有任务的返回值。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值