线程池小例一枚（及注意事项）

之前都是参考别人的代码，现如今自己动手来写一个个人版本的线程池，线程池的实现本身并不复杂，无非就是创建一些线程然后让这些线程处于条件等待状态（可以用条件变量，也可以用信号量来实现）。这是最基本的原理，原理的理解很简单，但重要的是实现的细节问题。


线程池的实现：
包含内容：
1、线程数量N；
2、线程的工作内容函数，void* worker(void* arg);
3、共享数据，这里使用标准库中的list来实现，在实现过程中为了通用性，使用C++模板，
template
list m_queue;
4、互斥锁、信号量；


包含的各个内容中需要注意：
1、数量调整随着性能的增长的变化；
2、工作函数，在pthread_create()中，封装成类的线程池中在创建线程的时候要把worker设置成为static类型，否则会涉及类型转换问题，无法创建线程。
3、因为工作函数worker要使用共享数据，但是在类中static函数不可访问对象的内容，所以要把共享数据的内容设置成为static，这里也要注意一下类中的静态数据的初始化问题。
4、保持多线程的互斥和同步，同样设置成为static类型。

main.cc:

#include <iostream>
#include <stdlib.h>

#include <unistd.h>

#include "locker.h"
#include "threadpool.h"

using namespace std;

int main(){
    threadpool<int> pool;

    int arr[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};//注意传递给线程池的地址需要是请求的数据的地址，不能是临时对象的地址。
    for(int i = 0; i < 10; i++){
        pool.append(arr+i);
    }

    sleep(10);

    return 0;
}

locker.h

#ifndef LOCKER_H
#define LOCKER_H

#include <iostream>
#include <pthread.h>
#include <semaphore.h>
using namespace std;

class locker{
public:
    locker(){
        if(pthread_mutex_init(&m_locker, NULL) != 0){
            cout << "pthread_mutex_init failed." << endl;
            exit(1);
        }
    }

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

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

    bool unlock(){
        return pthread_mutex_unlock(&m_locker) == 0;
    }

private:
    pthread_mutex_t m_locker;
};


class sem{
public:
    sem(){
        if(sem_init(&m_sem, 0, 0) != 0){
            cout << "sem_init failed." << endl;
            exit(1);
        }
    }

    ~sem(){
        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;
};

class cond{
public:
    cond(){
        if(pthread_mutex_init(&m_mutex, NULL) != 0){
            cout << "pthread_mutex_init() of cond failed " << endl;
            exit(1);
        }
        if(pthread_cond_init(&m_cond, NULL) != 0){
            pthread_mutex_destroy(&m_mutex);
            cout << "pthread_cond_init() of cond failed " << endl;
            exit(1);
        }
    }

    ~cond(){
        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

threadpool：

#ifndef THREADPOLL_H
#define THREADPOLL_H

#include <iostream>
#include <pthread.h>
#include <list>
#include <unistd.h>

#include "locker.h"

using namespace std;

#define N 8

using namespace std;


template <typename T>
class threadpool{
public:
    threadpool();
    ~threadpool();
    bool append(T* request);

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

private:
    static pthread_t* m_threads;
    static locker m_locker;
    static sem m_sem;
    static list<T*> m_queue;
    static bool m_stop;
};

template <typename T>
pthread_t* threadpool<T>::m_threads = NULL;

template <typename T>
bool threadpool<T>::m_stop = false;

template <typename T>
locker threadpool<T>::m_locker;

template <typename T>
sem threadpool<T>::m_sem;

template <typename T>
list<T*> threadpool<T>::m_queue;

template <typename T>
threadpool<T>::threadpool(){
    m_threads = new pthread_t[N];
    if(m_threads == NULL){
        cout << "new pthread_t[N] error." << endl;
        exit(1);
    }
    for(int i = 0; i < N; i++){
        if(pthread_create(m_threads+i, NULL, worker, NULL) != 0){
            delete [] m_threads;
            cout << "m_threads[] pthread_create failed." << endl;
            exit(1);
        }else{
            cout << "m_threads[" << i << "] create successfully." << endl;
        }
        if(pthread_detach(m_threads[i])){
            delete [] m_threads;
            cout << "m_threads[] pthread_create failed." << endl;
            exit(1);
        }
    }
}


template <typename T>
threadpool<T>::~threadpool(){
    delete[] m_threads;
    m_stop = true;
}


template <typename T>
bool threadpool<T>::append(T* request){
    m_locker.lock();

    m_queue.push_back(request);

    m_locker.unlock();

    m_sem.post();

    return true;
}


template <typename T>
void* threadpool<T>::worker(void* arg){
//    threadpool* pool = (threadpool*)arg;
    T* temp;
    while(m_stop == false){
        m_sem.wait();
        m_locker.lock();

        temp = m_queue.front();
        m_queue.pop_front();

        m_locker.unlock();

        cout << "operations in workers of threadpool." << *temp << endl;; //对request的操作

        sleep(1);
    }
}


#endif

以上只是简单的代码小例，不可作为正式工程使用，未考虑到的地方很多如防御性编程等。