內存池、進程池、線程池介紹及線程池C++實現

時間  2020-05-10
標籤 內存 進程 線程 介紹 c++ 實現 欄目 C&C++ 简体版
原文   原文鏈接

本文轉載於：http://www.javashuo.com/article/p-povmwlto-cm.html

內存池

日常咱們使用new、malloc在堆區申請一塊內存，但因爲每次申請的內存大小不同就會產生不少內存碎片，形成很差管理與浪費的狀況。ios

內存池則是在真正使用內存以前，先申請分配必定數量的、大小相等(通常狀況下)的內存塊留做備用。當有新的內存需求時，就從內存池中分出一部份內存塊，若內存塊不夠再繼續申請新的內存。這樣作的一個顯著優勢是儘可能避免了內存碎片，使得內存分配效率獲得提高。程序員

進程池&&線程池

這兩個問題有必定的類似度，在面向對象程序編程中，對象的建立與析構都是一個較爲複雜的過程，較費時間，因此爲了提升程序的運行效率儘量減小建立和銷燬對象的次數，特別是一些很耗資源的對象建立和銷燬。編程

因此咱們能夠建立一個進程池（線程池）,預先放一些進程（線程）進去,要用的時候就直接調用,用完以後再把進程歸還給進程池,省下建立刪除進程的時間,不過固然就須要額外的開銷了。
利用線程池與進程池可使管理進程與線程的工做交給系統管理，不須要程序員對裏面的線程、進程進行管理。服務器

線程池主要用於

一、須要大量的線程來完成任務，且完成任務的時間比較短。 WEB服務器完成網頁請求這樣的任務，使用線程池技術是很是合適的。由於單個任務小，而任務數量巨大，你能夠想象一個熱門網站的點擊次數。但對於長時間的任務，好比一個Telnet鏈接請求，線程池的優勢就不明顯了。由於Telnet會話時間比線程的建立時間大多了。網絡

二、對性能要求苛刻的應用，好比要求服務器迅速響應客戶請求。多線程

三、接受突發性的大量請求，但不至於使服務器所以產生大量線程的應用。突發性大量客戶請求，在沒有線程池狀況下，將產生大量線程，雖然理論上大部分操做系統線程數目最大值不是問題，短期內產生大量線程可能使內存到達極限，並出現"OutOfMemory"的錯誤。併發

線程池優勢

首先說一下多線程的好處：多線程技術主要解決處理器單元內多個線程執行的問題，它能夠顯著減小處理器單元的閒置時間，增長處理器單元的吞吐能力。函數

咱們知道應用程序建立一個對象，而後銷燬對象是很耗費資源的。建立線程，銷燬線程，也是如此。所以，咱們就預先生成一些線程，等到咱們使用的時候在進行調度，因而，一些"池化資源"技術就這樣的產生了。性能

本文所提到服務器程序是指可以接受客戶請求並能處理請求的程序，而不僅是指那些接受網絡客戶請求的網絡服務器程序。網站

多線程技術主要解決處理器單元內多個線程執行的問題，它能夠顯著減小處理器單元的閒置時間，增長處理器單元的吞吐能力。但若是對多線程應用不當，會增長對單個任務的處理時間。能夠舉一個簡單的例子：

假設在一臺服務器完成一項任務的時間爲T

T1 建立線程的時間

T2 在線程中執行任務的時間，包括線程間同步所需時間

T3 線程銷燬的時間

顯然T ＝ T1＋T2＋T3。注意這是一個極度簡化的假設。

能夠看出T1,T3是多線程自己的帶來的開銷，咱們渴望減小T1,T3所用的時間，從而減小T的時間。但一些線程的使用者並無注意到這一點，因此在程序中頻繁的建立或銷燬線程，這致使T1和T3在T中佔有至關比例。顯然這是突出了線程的弱點（T1，T3），而不是優勢（併發性）。

線程池技術正是關注如何縮短或調整T1,T3時間的技術，從而提升服務器程序性能的。它把T1，T3分別安排在服務器程序的啓動和結束的時間段或者一些空閒的時間段，這樣在服務器程序處理客戶請求時，不會有T1，T3的開銷了。

線程池不只調整T1,T3產生的時間段，並且它還顯著減小了建立線程的數目。在看一個例子：

假設一個服務器一天要處理50000個請求，而且每一個請求須要一個單獨的線程完成。咱們比較利用線程池技術和不利於線程池技術的服務器處理這些請求時所產生的線程總數。在線程池中，線程數通常是固定的，因此產生線程總數不會超過線程池中線程的數目或者上限（如下簡稱線程池尺寸），而若是服務器不利用線程池來處理這些請求則線程總數爲50000。通常線程池尺寸是遠小於50000。因此利用線程池的服務器程序不會爲了建立50000而在處理請求時浪費時間，從而提升效率。

線程池的簡單實現

#ifndef __THREAD_H     
#define __THREAD_H     
    
#include <vector>     
#include <string>     
#include <pthread.h>     
    
using namespace std;    
    
/**  
 * 執行任務的類，設置任務數據並執行  
 */    
class CTask    
{    
protected:    
    string m_strTaskName;  /** 任務的名稱 */    
    void* m_ptrData;       /** 要執行的任務的具體數據 */    
  
public:    
    CTask(){}  
    CTask(const string& taskName)    
    {    
        m_strTaskName = taskName;    
        m_ptrData = NULL;    
    }    
    virtual ~CTask(){}    
  
    virtual int Run() = 0;    
  
    void SetData(void* data);    /** 設置任務數據 */    
};    
    
/**  
 * 線程池管理類的實現  
 */    
class CThreadPool    
{    
private:    
    static  vector<CTask*> m_vecTaskList;     /** 任務列表 */    
    static  bool shutdown;                    /** 線程退出標誌 */             
    int     m_iThreadNum;                     /** 線程池中啓動的線程數 */    
    pthread_t   *pthread_id;    
        
    static pthread_mutex_t m_pthreadMutex;    /** 線程同步鎖 */    
    static pthread_cond_t m_pthreadCond;      /** 線程同步的條件變量 */    
    
protected:    
    static void* ThreadFunc(void * threadData); /** 新線程的線程回調函數 */    
    static int MoveToIdle(pthread_t tid);       /** 線程執行結束後，把本身放入到空閒線程中 */    
    static int MoveToBusy(pthread_t tid);       /** 移入到忙碌線程中去 */    
        
    int Create();          /** 建立線程池中的線程 */    
    
public:    
    CThreadPool(int threadNum = 10);    
  
    int AddTask(CTask *task);      /** 把任務添加到任務隊列中 */    
    int StopAll();                 /** 使線程池中的線程退出 */    
    int getTaskSize();             /** 獲取當前任務隊列中的任務數 */    
};    
    
#endif

　　thread.cpp:

#include "Thread.h"     
#include <iostream>     
#include "stdlib.h"     
    
void CTask::SetData(void * data)    
{    
    m_ptrData = data;    
}    
    
vector<CTask*> CThreadPool::m_vecTaskList;         //任務列表     
bool CThreadPool::shutdown = false;    
        
pthread_mutex_t CThreadPool::m_pthreadMutex = PTHREAD_MUTEX_INITIALIZER;     
pthread_cond_t CThreadPool::m_pthreadCond = PTHREAD_COND_INITIALIZER;    
    
/**  
 * 線程池管理類構造函數  
 */    
CThreadPool::CThreadPool(int threadNum)    
{    
    this->m_iThreadNum = threadNum;    
    cout << "I will create " << threadNum << " threads" << endl;    
    Create();    
}    
    
/**  
 * 線程回調函數  
 */    
void* CThreadPool::ThreadFunc(void* threadData)    
{    
    pthread_t tid = pthread_self();    
    while (1)    
    {    
        pthread_mutex_lock(&m_pthreadMutex);    
        while (m_vecTaskList.size() == 0 && !shutdown)    
        {    
            pthread_cond_wait(&m_pthreadCond, &m_pthreadMutex);    
        }    
            
        if (shutdown)    
        {    
            pthread_mutex_unlock(&m_pthreadMutex);    
            printf("thread %lu will exit\n", pthread_self());    
            pthread_exit(NULL);     
        }    
            
        printf("tid %lu run\n", tid);    
        vector<CTask*>::iterator iter = m_vecTaskList.begin();    
            
        /**  
        * 取出一個任務並處理之  
        */    
        CTask* task = *iter;    
        if (iter != m_vecTaskList.end())    
        {    
            task = *iter;    
            m_vecTaskList.erase(iter);    
        }    
            
        pthread_mutex_unlock(&m_pthreadMutex);    
            
        task->Run(); /** 執行任務 */    
        printf("tid:%lu idle\n", tid);    
    }    
    return (void*)0;    
}    
    
/**  
 * 往任務隊列裏邊添加任務併發出線程同步信號  
 */    
int CThreadPool::AddTask(CTask *task)    
{    
    pthread_mutex_lock(&m_pthreadMutex);    
    this->m_vecTaskList.push_back(task);    
    pthread_mutex_unlock(&m_pthreadMutex);    
    pthread_cond_signal(&m_pthreadCond);    
    return 0;    
}    
    
/**  
 * 建立線程  
 */    
int CThreadPool::Create()    
{    
    pthread_id = (pthread_t*)malloc(sizeof(pthread_t) * m_iThreadNum);    
    for(int i = 0; i < m_iThreadNum; i++)    
    {    
        pthread_create(&pthread_id[i], NULL, ThreadFunc, NULL);    
    }    
    return 0;    
}    
    
/**  
 * 中止全部線程  
 */    
int CThreadPool::StopAll()    
{    
    /** 避免重複調用 */    
    if (shutdown)    
    {    
        return -1;      
    }    
    printf("Now I will end all threads!!\n");    
    /** 喚醒全部等待線程，線程池要銷燬了 */    
    shutdown = true;    
    pthread_cond_broadcast(&m_pthreadCond);    
        
    /** 阻塞等待線程退出，不然就成殭屍了 */    
    for (int i = 0; i < m_iThreadNum; i++)    
    {    
        pthread_join(pthread_id[i], NULL);      
    }    
        
    free(pthread_id);    
    pthread_id = NULL;    
        
    /** 銷燬條件變量和互斥體 */    
    pthread_mutex_destroy(&m_pthreadMutex);    
    pthread_cond_destroy(&m_pthreadCond);    
        
    return 0;    
}    
    
/**  
 * 獲取當前隊列中任務數  
 */    
int CThreadPool::getTaskSize()    
{    
    return m_vecTaskList.size();        
}

　　main.cpp:

#include "Thread.h"     
#include <iostream>     
#include <unistd.h>     
#include <stdlib.h>     
    
class CMyTask: public CTask    
{    
public:    
    CMyTask(){}    
        
    inline int Run()    
    {    
        printf("%s\n", (char*)this->m_ptrData);    
        sleep(10);    
        return 0;    
    }    
};    
    
int main()    
{    
    CMyTask taskObj;    
        
    char szTmp[] = "this is the new thread running";    
    taskObj.SetData((void*)szTmp);    
    CThreadPool threadPool(10);    
        
    for(int i = 0; i < 20; i++)    
    {    
        threadPool.AddTask(&taskObj);    
    }    
        
    while(1)    
    {    
        printf("there are still %d tasks need to handle\n", threadPool.getTaskSize());    
        if (threadPool.getTaskSize() == 0)    
        {    
            if (threadPool.StopAll() == -1)    
            {       
                printf("Now I will exit from main\n");    
                exit(0);    
            }    
        }    
        sleep(2);    
    }    
        
    return 0;    
}
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程