linux 线程池

thread_pool.h

/* * thread_pool.h * * Created on: May 2, 2014 * Author: root */#ifndef THREAD_POOL_H_#define THREAD_POOL_H_#include "thread_locker.h"#include "thread_sem.h"#include <list>#include <cstdio>#include <exception>#include <pthread.h>template<typename T>class ThreadPool {public:        ThreadPool( int thread_number = 1, int max_requests = 10000 );        ~ThreadPool();        bool Push( T* request ); //推送任务private:        static void* Worker(void* arg);// 工作线程运行的函数        void Run();        int m_thread_number; //线程池中到线程数        int m_max_requests; //请求队列中允许的最大请求数        pthread_t* m_threads; //描述线程池到数组，其大小为m_thread_number        std::list< T* > m_workqueue; //队列        ThreadLocker m_queuelocker; /*保护请求队列的互斥锁*/        ThreadSem m_queuestat; /*是否有任务需要处理*/        bool m_stop; /*是否结束线程*/};template< typename T >ThreadPool< T >::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 <= 0 ) || ( max_requests <= 0 ) )    {        throw std::exception();    }    m_threads = new pthread_t[ m_thread_number ];    if( ! m_threads )    {        throw std::exception();    }    for ( int i = 0; i < thread_number; ++i )    {        printf( "create the %dth thread\n", i );        if( pthread_create( m_threads + i, NULL, Worker, this ) != 0 )        {            delete [] m_threads;            throw std::exception();        }        if( pthread_detach( m_threads[i] ) )        {            delete [] m_threads;            throw std::exception();        }    }}template< typename T >ThreadPool< T >::~ThreadPool(){    delete [] m_threads;    m_stop = true;}template< typename T >bool ThreadPool< T >::Push( T* request ){    m_queuelocker.Lock(); // 工作队列加锁    if ( m_workqueue.size() > m_max_requests )    {        m_queuelocker.Unlock();        return false;    }    m_workqueue.push_back( request );    m_queuelocker.Unlock();    m_queuestat.Post();    return true;}template< typename T >void* ThreadPool< T >::Worker( void* arg ){    ThreadPool* pool = ( ThreadPool* )arg;    pool->Run();    return pool;}template< typename T >void ThreadPool< T >::Run(){    while ( ! m_stop )    {        m_queuestat.Wait();        m_queuelocker.Lock();        if ( m_workqueue.empty() )        {            m_queuelocker.Unlock();            continue;        }        T* request = m_workqueue.front(); //返回链表第一个元素的引用        m_workqueue.pop_front();// 删除链表头到一个元素        m_queuelocker.Unlock();        if ( ! request )        {            continue;        }        request->process();    }}#endif /* THREAD_POOL_H_ */

thread_locker.h

/* * thread_locker.h * * Created on: May 2, 2014 * Author: root */#ifndef LOCKER_H_#define LOCKER_H_#include <exception>#include <pthread.h>class ThreadLocker {public:        ThreadLocker()        {                if(pthread_mutex_init(&m_mutex,NULL) != 0)                {                        throw std::exception();                }        }        ~ThreadLocker()        {                pthread_mutex_destroy(&m_mutex);        }        //加锁        bool Lock()        {                return pthread_mutex_lock(&m_mutex) == 0;        }        //解锁        bool Unlock()        {                return pthread_mutex_unlock(&m_mutex) == 0;        }private:        pthread_mutex_t m_mutex;};#endif

thread_cond.h

/* * thread_cond.h * * Created on: May 3, 2014 * Author: root */#ifndef COND_H_#define COND_H_#include <pthread.h>#include <exception>class ThreadCond{public:        ThreadCond()        {                if( pthread_mutex_init( &m_mutex, NULL ) != 0)                {                        throw std::exception();                }                if( pthread_cond_init( &m_cond, NULL) != 0)                {                        //释放资源                        pthread_mutex_destroy( &m_mutex);                        throw std::exception();                }        }        //销毁条件变量        ~ThreadCond()        {                pthread_mutex_destroy( &m_mutex );                pthread_cond_destroy( &m_cond);        }        //等待条件变量        bool Wait()        {                int ret = 0;                pthread_mutex_lock( &m_mutex);                ret = pthread_cond_wait( &m_cond, &m_mutex );                pthread_mutex_unlock( &m_mutex );                return ret == 0;        }        //唤醒等待条件变量的线程        bool Signal()        {                return pthread_cond_signal( &m_cond ) == 0;        }private:        pthread_mutex_t m_mutex;        pthread_cond_t m_cond;};#endif /* COND_H_ */

thread_sems.h

/* * thread_sems.h * * Created on: May 2, 2014 * Author: root */#ifndef SEMS_H_#define SEMS_H_#include <semaphore.h>#include <exception>class ThreadSem{public:        ThreadSem()    {        if( sem_init( &m_sem, 0, 0 ) != 0 )        {            throw std::exception();        }    }    //销毁信号量    ~ThreadSem()    {        sem_destroy( &m_sem );    }    //等待信号量    bool Wait()    {        return sem_wait( &m_sem ) == 0;    }    //增加信号量    bool Post()    {        return sem_post( &m_sem ) == 0;    }private:    sem_t m_sem;};#endif /* SEMS_H_ */

file_test.h

/* * file_test.h * * Created on: May 2, 2014 * Author: root */#ifndef FILE_TEST_H_#define FILE_TEST_H_#include <stdio.h>#include <stdlib.h>#include <iostream>#include <string.h>class FileTest {public:        FileTest();        virtual ~FileTest();        void process();        void setFileName(std::string filename);        static void test();private:         std::string m_filename;         //bool status;};#endif /* FILE_TEST_H_ *//* * file_test.cpp * * Created on: May 2, 2014 * Author: root */#include "file_test.h"#include <string.h>#include <stdio.h>#include <stdlib.h>#include <iostream>#include <cstdio>#include <iostream>#include <fstream>#include <sstream>#include "log/log.h"#include<fstream>using namespace std;static int num = 0;FileTest::FileTest():m_filename("") {        // TODO Auto-generated constructor stub}FileTest::~FileTest() {        // TODO Auto-generated destructor stub}void FileTest::setFileName(std::string filename){        m_filename = filename;}std::string IntToString(int i){        string c;        ostringstream oss;        oss<<i;        c=oss.str();        return c;}static Logs logger=Logs::instance();void FileTest::process(){        num++;        logger.write_error("num:");        logger.write_error(IntToString(num).c_str());        logger.write_error(m_filename.c_str());}void FileTest::test(){num++;cout << num << endl;}

main.c

#include <string.h>#include <stdio.h>#include <stdlib.h>#include <sstream>#include "file_test.h"#include "thread/thread_pool.h"using namespace std;static std::string IntToString(int i){        string c;        ostringstream oss;        oss<<i;        c=oss.str();        return c;}int main(){        ThreadPool<FileTest>* thread = new ThreadPool<FileTest>(5,1024);        FileTest* file_test = new FileTest[5];        for(int i = 0; i < 5; ++i){                std::string filename("filename");                filename.append(IntToString(i));                filename.append(".txt");                (file_test + i)->setFileName(filename);                thread->Push(file_test + i);        }        while(false)        {                for(int i = 0; i < 24; ++i)                {                        (file_test + i)->test();                }        }        sleep(5);        delete []file_test;        delete thread;        return 0;}