成人免费xxxxx在线视频软件_久久精品久久久_亚洲国产精品久久久_天天色天天色_亚洲人成一区_欧美一级欧美三级在线观看

線程池的使用場景和代碼實現！

作者：txp
開發 前端
好了簡單說了一下，后面的哪些什么內存池、連接池，后期復習都再給大家分享吧，今天我們的主題是線程池。

[[403953]]

前言：

大家周末好，今天給大家帶來一篇技術文章，是關于線程池的實現和使用場景;我相信大家在公司里面的代碼里面經常看到這個線程池的用法，或者甚至大家可能會聽到內存池、對象池、連接池等這些專業術語，反正就很多帶池的專業術語，不過你會發現他們都有一個共同的特點就是“屁股”末尾都帶一個“池”字，池字，簡單理解就是用來存東西的，舉個簡單例子來說，你比如游泳池里面可以用來存儲水!

好了簡單說了一下，后面的哪些什么內存池、連接池，后期復習都再給大家分享吧，今天我們的主題是線程池。

一、線程池的實現：

1、為啥要用到線程池?

多線程編程，大家這個應該很熟悉了，上次有一位朋友問了一個問題，一個線程大概占用多大內存大小，一般按照POSIX標準來算的話，一個線程大概在8M左右，但是我們一般內存資源有限，在進行高并發的時候，比如說，多個客戶端同時向服務器端發送請求：

這個時候，你想一下給這么多客戶端都分配開一個大概8M的內存大小，這現實嘛，顯然行不通的嘛，我們來計算一下：

  • 一個線程：8M
  • 1024M可以開128個線程
  • 16G內存大小可以開16x128,計算下來大概在2048個線程

所以百萬級個客戶端都分配開一個線程的話，那內存資源肯定是不夠的，所以這涉及到我們的線程池了，這也是為什么在這種場景下要使用線程池了!

為了幫助大家更好的理解線程池這個概念，我們還是舉一個生活當中的實際場景吧;去銀行存錢或者辦理相關業務，這個大家都不陌生吧，你到了銀行里面，一般來說的話，都要排隊在窗口等待前面的人把業務辦理完，才能夠輪到你來辦理你想要辦理的業務，而窗口里面就是幫你辦理各種業務的銀行工作人員，同時一般窗口辦理業務上面有一個提示電子信息，如果輪到了你，就會通知你，你就知道了輪到自己辦理業務了。

這里換個專業的角度來說(也不專業哈，只是一個打比方)，你來辦理的這個業務就是一個任務(也就是一個線程，可以說成任務隊列，因為要排隊嘛，不可能一下子執行那么多任務，任務隊列里面的任務必須一個一個執行)，而銀行工作人員相當于從任務隊列里面拿一個任務來執行，你可以把銀行工作人員看成是執行任務隊列;而電子顯示通知信息，你可以把它看成防止多個業務同時在一個窗口讓一個銀行工作人員來辦理，兩個窗口也就是兩個銀行工作人員同時辦理一個業務，也就是說這個電子顯示信息是一個管理組件，管理任務是否可以去辦理，管理著銀行工作人員是否開始辦理業務任務，不讓他們亂套了，合理有效的執行任務。

那么你從上面可以看到，使用線程池的優點了：

  • 避免線程太多，使得內存耗盡
  • 開始的時候，你可以把創建好的線程放入到線程池當中去，當我們要用的時候，就可以從線程池里面拿一個線程來用，用完這個線程的時候，再把這個線程放回到線程池里面;避免創建線程與銷毀的代價

2、線程池實現模板步驟：

其實這個線程池的實現大概流程步驟都差不多，如果大家平時仔細看公司代碼或者說自己去實現一個線程池的話，大概實現模板如下：

  • 任務隊列(前來辦理業務的人)
  • 執行隊列(就是銀行工作人員執行任務隊列里面的任務)
  • 管理組件(管理任務有序的執行)

3、線程池實現結構體定義：

任務隊列：

  1. struct nTask 
  2. { 
  3. //用函數指針來存放不同的任務 
  4.   void (*task_func)(struct nTask *task); 
  5.    
  6.   //這個參數用來做任務執行的參數 
  7.   void *user_data; 
  8.  
  9. //鏈表節點的定義，這里采用鏈表的方式實現 
  10. struct nTask *prev; 
  11. struct nTask *next; 
  12.  
  13. }; 
  • 執行隊列：
  1. struct nWorker 
  2. { 
  3.   pthread_t threadid;//線程id 
  4.    
  5.   int terminate;//表示是否終止任務 
  6.  //表示銀行工作人員要執行任務還要向執行組件通告一下 
  7.   struct nManager *manager; 
  8.    
  9.   //還是通過鏈表的方式來實現執行隊列 
  10.   struct nWorker *prev; 
  11.   struct nWorker *next; 
  12.  
  13. }; 

注意：這里如果沒有辦理業務的人來，銀行工作人員只能在哪里等待任務的到來，然后再執行任務。

  • 管理組件：
  1. typedef struct nManager 
  2. { 
  3.  
  4.   struct nTask *task; 
  5.   struct nWorker *workers; 
  6.    
  7.   pthread_mutex_t mutex;//互斥鎖 
  8.   pthread_cond_t cond;//條件變量 
  9. }ThreadPool; 
  • 鏈表的插入和刪除模板：
  1. //插入 
  2. #define LIST_INSERT(item,list) do{\ 
  3.   item->prev=NULL;                \ 
  4.   item->next=list;                \ 
  5. if((list)!=NULL) list->prev=item;\ 
  6. list=item; 
  7. }while(0) 
  8.  
  9. //刪除 
  10. #define LIST_REMOVE(item,list) do{ \ 
  11. if(item->prev != NULL) item->prev->next = item->next; \ 
  12. if(item->next !=NULL) item->next->prev=item->prev;  \ 
  13.  
  14. if(list == item)list = item->netx; \  
  15. item->prev=item->next=NULL;\ 
  16. }while(0) 
  17.  
  18. } 

4、線程池接口定義如下：

1、線程池初始化接口：

  1. int nThreadPoolCreate(ThreadPool *pool,int numWorkers) 
  2. { 
  3. //參數pool表示線程池，numWorkers表示線程池里面有多少個任務 
  4. } 

2、線程池銷毀接口：

  1. int nThreadPoolDestory(ThreadPool *pool,int nWorker) 
  2. { 
  3.  
  4. } 

3、往線程池里面添加任務接口：

  1. int nThreadPoolPushTask(ThreadPool *pool,struct nTask *task) 
  2. { 
  3.  
  4.  
  5. } 

4、線程回調函數：

  1. void *nThreadPoolCallback(void *arg) 
  2. { 
  3.  
  4.  
  5. } 

二、線程池工程代碼：

  1. #include <stdio.h> 
  2. #include <string.h> 
  3. #include <stdlib.h> 
  4. #include <pthread.h> 
  5.  
  6. //鏈表插入 
  7. #define LIST_INSTER(item,list)do{ \ 
  8. item->prev=NULL;       \ 
  9. item->next=next;       \ 
  10. if(list!=NULL) list->prev=item; \ 
  11. list=item; 
  12. }while(0) 
  13.  
  14. //刪除 
  15. #define LIST_REMOVE(item,list)do {  \ 
  16. if(item->prev!=NULL)item->prev->next=item->next; \ 
  17. if(item->next!=NULL)itme->next->prev=item->prev;\ 
  18.  
  19. if(list==item)list=item->next; 
  20. item->prev=item->next=NULL; 
  21. }while(0) 
  22.  
  23. //任務隊列 
  24.  
  25. struct nTask 
  26. { 
  27.   void(*task_funt)(struct nTask *task); 
  28.   void *uset_data; 
  29.    
  30.   struct nTask *prev; 
  31.   struct nTask *next; 
  32. }; 
  33.  
  34. //執行隊列 
  35. struct nWorker 
  36. { 
  37.   pthread_t threadid; 
  38.   int terminate; 
  39.    
  40.   struct nManager *manager; 
  41.    
  42.   struct nWorker *prev; 
  43.   struct nWorker *next; 
  44. }; 
  45.  
  46. //管理組件 
  47. typedef struct nManager 
  48. { 
  49.   struct nTask *tasks; 
  50.   struct nWoker *workers; 
  51.    
  52.   pthread_mutex_t mutex; 
  53.   pthread_cond_t cond; 
  54.  
  55. }ThreadPool; 
  56. //線程回調函數 
  57. void *nThreadPoolCallback(void *arg) 
  58. { 
  59.   struct nWorker *worker=(struct nWorker*)arg; 
  60.    
  61.   while(1) 
  62.   { 
  63.     //判斷是否有任務 
  64.     pthread_mutex_lock(&worker->manager-mutex); 
  65.     while(worker->manager->tasks==NULL) 
  66.     { 
  67.       if(worker-terminate) 
  68.         break; 
  69.       pthread_cond_wait(&worker->manager->cond,&worker->manager->mutex);//如果沒有任務，一直等待任務的到來 
  70.     } 
  71.     if(worker->terminate) 
  72.     { 
  73.       pthread_mutex_unlock(&worker->manager->mutex); 
  74.       break; 
  75.      
  76.     } 
  77.   struct nTask *task = worker->manager->tasks; 
  78.   LIST_REMOVE(task,worker->manager->tasks); 
  79.   pthread_mutex_unlock(&worker->manager->mutex); 
  80.   task->task_func(task); 
  81.    
  82.   } 
  83.  
  84. free(worker); 
  85. } 
  86.  
  87. //創建線程池 
  88. int nThreadPoolCreate(ThreadPool *pool, int numWorkers) 
  89. { 
  90.   if(pool == NULL) return -1; 
  91.   if(numWorkers < 1)numWorkers =1; 
  92.   memset(&pool,0,sizeof(ThreadPool)); 
  93.  
  94.   //開始初始化 
  95.   pthread_cond_t blank_cond = PTHREAD_COND_INITIALIZER; 
  96.  
  97.   memcpy(&pool->cond,&blank_cond,sizeof(pthread_cond_t)); 
  98.  
  99.   pthread_mutex_t blank_mutex =PTHREAD_MUTEX_INITIALIZER; 
  100.   memcpy(&pool->mutex,&blank_mutex,sizeof(pthread_mutex_t)); 
  101.  
  102.   int i =0;//開線程的個數,也就是執行任務的個數 
  103.  
  104.   for(i=0;i < numWorkers;i++) 
  105.   { 
  106.     struct nWorker *worker =(struct nWorker*)malloc(sizeof(struct nWorker)); 
  107.     if(worker == NUll) 
  108.     { 
  109.         perror("malloc"); 
  110.         return -2; 
  111.     } 
  112.     memset(worker,0,sizeof(struct nWorker)); 
  113.     worker->manager=pool; 
  114.  
  115.   //創建線程 
  116.   int ret=pthread_create(&worker->pthreadid,NULL,nThreadPoolCallback,worker); 
  117.    
  118.     if(ret) 
  119.     { 
  120.       perror("pthread_create"); 
  121.       free(worker); 
  122.       return -3; 
  123.     } 
  124.     LIST_INSERT(worker,pool->workers); 
  125.   } 
  126. } 
  127.  
  128. //線程池銷毀 
  129.  
  130. int nThreadPoolDestory(ThreadPool *pool,int nWorker) 
  131. { 
  132.   struct nWorker *worker = NULL; 
  133.   for(worker=pool->workers;worker!=NULL;worker=worker->next) 
  134.   { 
  135.     worker->terminate; 
  136.   } 
  137. pthread_mutex_lock(&pool->mutex); 
  138. pthread_cond_broadcast(&pool->cond);//做一個廣播通知 
  139. pthread_mutex_unlock(&pool->mutex); 
  140.  
  141. pool->workers = NULL; 
  142. pool->tasks = NULL; 
  143. } 
  144.  
  145. //往線程池里面添加任務 
  146.  
  147. int nThreadPoolPushTask(ThreadPool *pool,struct nTask *task) 
  148. { 
  149.   pthread_mutex_lock(&pool->mutex); 
  150.   LIST_INSERTER(task,pool->tasks); 
  151.   pthread_cond_sigal(&pool->cond);// 發送一個信號，有人來辦理業務了 
  152.   pthread_mutex_unlock(&pool-mutex); 
  153. } 
  154.  
  155.  
  156. #if 1 
  157.  
  158. #define THREADPOOL_INIT_COUNT 20 
  159. #define TASK_INIT_SIZE   1000 
  160.  
  161.  
  162. void task_entry(struct nTask *task) { //type  
  163.  
  164.  //struct nTask *task = (struct nTask*)task; 
  165.  int idx = *(int *)task->user_data; 
  166.  
  167.  printf("idx: %d\n", idx); 
  168.  
  169.  free(task->user_data); 
  170.  free(task); 
  171. } 
  172.  
  173.  
  174. int main(void) { 
  175.  
  176.  ThreadPool pool = {0}; 
  177.   
  178.  nThreadPoolCreate(&pool, THREADPOOL_INIT_COUNT); 
  179.  // pool --> memset(); 
  180.   
  181.  int i = 0; 
  182.  for (i = 0;i < TASK_INIT_SIZE;i ++) { 
  183.   struct nTask *task = (struct nTask *)malloc(sizeof(struct nTask)); 
  184.   if (task == NULL) { 
  185.    perror("malloc"); 
  186.    exit(1); 
  187.   } 
  188.   memset(task, 0, sizeof(struct nTask)); 
  189.  
  190.   task->task_func = task_entry; 
  191.   task->user_data = malloc(sizeof(int)); 
  192.   *(int*)task->user_data  = i; 
  193.  
  194.    
  195.   nThreadPoolPushTask(&pool, task); 
  196.  } 
  197.  
  198.  getchar(); 
  199.   
  200. } 

代碼量稍微有點多，大家可以多多看看幾遍!

本文轉載自微信公眾號「txp玩Linux」，可以通過以下二維碼關注。轉載本文請聯系txp玩Linux公眾號。

 

責任編輯：武曉燕 來源： txp玩Linux
線程池使用場景
相關推薦

2024-11-27 08:15:50

2019-10-25 10:35:49

Java用法場景

2021-08-29 22:05:04

對象自動回收

2025-04-27 08:30:48

2023-05-16 07:47:18

RabbitMQ消息隊列系統

2023-04-03 11:01:26

低代碼平臺場景

2010-12-21 14:21:36

線程C#

2024-04-11 13:41:47

2021-09-11 15:26:23

Java多線程線程池

2018-04-02 14:50:22

Java多線程應用場景

2013-12-25 16:03:39

GitGit 命令

2022-08-29 09:06:43

hippo4j動態線程池

2022-05-06 13:30:56

TDD場景代碼

2022-02-13 23:10:46

Golang語言變量

2020-04-07 14:20:10

RabbitMMySQL數據庫

2013-10-15 10:11:33

產品測試使用場景產品

2024-12-31 07:56:33

Disruptor內存有界隊列消費模式

2015-01-16 11:30:07

Openstack分布式存儲

2018-05-16 15:26:43

數據庫MySQL主從復制

2023-05-15 08:50:58

ContextGolang
點贊
收藏

51CTO技術棧公眾號

主站蜘蛛池模板： 国内精品一区二区 | 亚洲一区二区精品视频在线观看 | 国产激情亚洲 | 日韩在线视频一区 | 国产视频福利一区 | 欧美国产日韩在线观看 | 欧美色性 | 免费观看的黄色网址 | 久久99国产精一区二区三区 | 国产精品黄视频 | 日本精品一区二区三区在线观看 | 精品在线观看入口 | 一区二区三区亚洲视频 | 中文字幕亚洲专区 | 国产在线精品一区二区三区 | 爱综合 | 成人动漫视频网站 | 国产精品99久久久久久www | 午夜精品久久久久久不卡欧美一级 | 国产一级视频在线 | 97国产一区二区精品久久呦 | 第一色在线 | 精品成人av| 日韩av免费在线观看 | 国产精品欧美一区喷水 | 激情免费视频 | 国产激情在线观看视频 | 韩国成人在线视频 | 国产区在线观看 | 欧美一区免费 | 精品国产乱码久久久久久丨区2区 | 国产区在线观看 | 国产高清在线精品 | 国产亚洲一区二区三区 | 国产成人精品网站 | 日本中文字幕在线观看 | 四虎影院久久 | 亚洲欧美视频 | 久久一区二区三区四区 | 九九九久久国产免费 | 婷婷开心激情综合五月天 |