我用过的设计模式（8）-- 装饰者模式

//pthreadpool.h

#pragma once

#include <pthread.h>
#include <unistd.h>
#include <list>	//据说list不安全，不安全就不安全吧，更不安全的都忍了
#include "Cond.h"	//封装过的条件变量类，继承自封装的mutex锁类，所以具有锁和条件变量的双重属性

using namespace std;

这里不打注释，这次的主角是它
class Task	//任务接口，每个任务必须实现的接口，以供工作线程调度任务的执行
{
public:
    Task() {}
    virtual ~Task() {}
    virtual int run() = 0; //留给子类实现
};

typedef list<Task*> list_task; //任务队列，用于暂存等待处理的任务，等待线程唤醒时处理，提供一种缓冲机制。

class Pthread_Pool	//线程池类
{
public:
    Pthread_Pool(unsigned int max = 100, unsigned int min = 10, unsigned int wait = 60);
    ~Pthread_Pool();
    void addTask(Task* task);	// 往任务队列中添加新线程
    看这里看这里

private:
    static void* taskThread(void* arg);// 工作线程
    void createThread();		// 新建一个线程
    void destroyThread();		// 销毁一个线程池

    unsigned int maxcount;		// 最大线程数
    unsigned int mincount; 		// 最小线程数
    unsigned int count;	 		// 当前线程池中线程数
    unsigned int waitcount; 	// 等待线程数
    unsigned int waitsec;		// 等待时间
    list_task	 taskList;      //任务队列
    Cond taskCond;    //任务锁，线程接任务时使用
    Cond cond;        //线程锁，创建线程时使用
    bool Stop;                  //线程池是否被允许运作，初始化线程池对象时置0，线程池销毁时置为1
};

class DoTask : public Task
{
public:
    DoTask(BtoC& send, PacketCommand1& packet);

    int run();
private:
    DB_command* task_db;
    BtoC* m_send;
    PacketCommand1 m_packet;
    PacketCommand3* f_packet;
};


class BackServer
{
public:
    BackServer(char* IPnum);
    ~BackServer() {}
    int run();
private:
    PacketCommand1 m_packet;
    BtoC m_send;
    Pthread_Pool* m_pool;
};

int BackServer::run()
{
    int n = 0;
    while (1)
    {
        n = m_send.Read_date(m_packet.getData());
        m_packet.setSize(n);
        DoTask* t = new DoTask(m_send, m_packet);
        m_pool->addTask(t);
    }
    return 0;
}

需要动态拓展一个类的功能，或者给一个类添加附加功能。
需要动态的给一个对象增加功能，这些功能可以动态的撤销。
需要为一批的兄弟类进行改装或加装功能，当然是首选装饰者模式。