實作一個執行緒池

一.執行緒最主要的三個同步機制

1.信號量

2.互斥鎖

3.條件變數

二.對三個同步機制分別實現一個包裝類別

#ifdef LOCKER_H
#define LOCKER_H


#include <pthread.h>
#include <semaphore.h>

/*信号量的封装*/
class sem
{
public:
    sem()
    {
        if( sem_init( &sem_like, 0, 0))
        {
            throw std::exception();
        }
    }

    ~sem()
    {
        sem_destroy( &sem_like);
    }

    bool wait()
    {
        return sem_wait( &sem_like)== 0;
    }

    bool post()
    {
        return sem_post( &sem_like)== 0;
    }

private:
    sem_t sem_like;
}


/*互斥锁的封装*/
class locker
{
public:
    locker()
    {
        if( pthread_mutex_init( &mutex_like,NULL) !=0)
        {
            throw std::exception();
        }
    }

    ~locker()
    {
        pthread_mutex_destroy( &mutex_like);
    }

    bool lock()
    {
        return pthread_mutex_lock( &mutex_like)== 0;
    }

    bool unlock()
    {
        return pthread_mutex_unlock( &mutex_like);
    }
private:
    pthread_mutex_t mutex_like;
}



/*条件变量的封装*/
class cond
{
public:
    cond()
    {
        if( pthread_mutex_init( &mutex_like,NULL)!= 0)
        {
            throw std::exception;
        }

        if( pthread_cond_init( &cond_like, NULL)!= 0)
        {
            //释放对应的互斥锁
            pthread_mutex_destroy( &mutex_like);
            throw std::exception;
        }
    }

    ~cond()
    {
        pthread_mutex_destroy( &mutex_like);
        pthread_cond_destroy( &cond_like);
    }

    bool wait()
    {
        int flag= 0;
        pthread_mutex_lock( &mutex_like);
        flag= pthread_cond_wait( &cond_like, &mutex_like);
        pthread_mutex_unlock( &mutex_like);
        return flag== 0;

    }

    bool signal()
    {
        return pthread_cond_signal( &cond_like)== 0;
    }

private:
    pthread_mutex_t mutex_like;
    pthread_cond_t cond_like;
}

#endif</semaphore.h></pthread.h>

。執行緒池

     動態建立執行緒十分消耗時間，如果有一個執行緒池，使用者要求到來時，從執行緒池取一個空閒的執行緒來處理使用者的請求，請求處理完後，執行緒又變成空閒狀態，等待下次被使用。

    

     核心資料結構有兩個：執行緒容器、請求佇列

       2.請求隊列

     這裡用list容器來存放所有請求，請求處理按fifo的順序

#ifndef THREADPOOL_H
#define THREADPOOL_H

#include <list>
#include <cstdio>
#include <exception>
#include <pthread.h>
#include "locker.h"

template
class threadpool
{
public:
    threadpool( int thread_number = 8, int max_requests = 10000 );
    ~threadpool();
    bool append( T* request );

private:
    static void* worker( void* arg );
    void run();

private:
    int thread_number_like;//当前线程池中的线程个数
    int max_requests_like;//最大请求数
    //pthread_t* threads_like;
    vector threads_like;//线程容器
    std::list workqueue_like;//请求队列
    locker queuelocker_like;//请求队列的访问互斥锁
    sem queuestat_like;//用于请求队列与空闲线程同步的信号量
    bool stop_like;//结束所有线程，线程池此时没有线程
};

template
threadpool::threadpool( int thread_number, int max_requests ) : 
        m_thread_number( thread_number ), m_max_requests( max_requests ), m_stop( false ), m_threads( NULL )
{
    if( ( thread_number 
threadpool::~threadpool()
{
    stop_like = true;
}

template
bool threadpool::append( T* request )
{
    queuelocker_like.lock();
    if ( workqueue_like.size() > max_requests_like )
    {
        queuelocker_like.unlock();
        return false;
    }
    workqueue_like.push_back( request );
    queuelocker_like.unlock();
    queuestat_like.post();
    return true;
}

template
void* threadpool::worker( void* arg )
{
    threadpool* pool = ( threadpool* )arg;//静态函数要调用动态成员run，必须通过参数arg得到
    pool->run();//线程的执行体
    return pool;
}

template
void threadpool::run()
{
    while ( ! m_stop )
    {
        queuestat_like.wait();
        queuelocker_like.lock();
        if ( workqueue_like.empty() )
        {
            queuelocker_like.unlock();
            continue;
        }
        T* request = workqueue_like.front();
        workqueue_like.pop_front();
        queuelocker_like.unlock();
        if ( ! request )
        {
            continue;
        }
        request->process();//执行当前请求所对应的处理函数
    }
}

#endif</pthread.h></exception></cstdio></list>

註：1.這裡的線程池模型中，每一個線程對應一個請求

        2.這種方式保證了用戶請求的及時方式保證了這種方式保證了這種方式處理，對請求的處理函數效能要求更小，因為這種模型並不要求請求處理過程是非堵塞的，因為一個請求的處理時延不會影響到系統對其他請求的處理（當然線程數必須能動態增加）。

        3.這種方式對高併發伺服器並不是最優的，類似於nginx的一個進程對應多個用戶請求的方式更有優勢，nginx模型的優勢主要有兩個：一：進程數固定，不會因為同時有很多執行緒或進程而佔用過多的記憶體。二：nginx的工作進程數一般與cpu的核數一致，並可以把一個進程綁定到一個核上，這樣就節省了進程切換或線程切換帶來的系統開銷

    

以上就介紹了實作一個線程池，包括了方面的內容，希望對PHP教程有興趣的朋友有所幫助。