使用C++实现的多线程定时任务管理器

先分析设计多线程定时任务管理器的思路。

首先,任务管理器类命名为WatchThread类,需要使用多线程,那我们可以使用thread类,并使用Thread里面的线程start和run。那我们可以设计如下:

#include<Thread.h>
class WatchThread:private Thead
{
        virtual void run()
        {
                cerr<<"WatchThread started"<<endl;
                while (is_running)
                {
                }
        }
}
现在这里面具备了执行任务了,现在差怎么样把任务弄进去?

其实任务可以看成任务管理器里面的产品,而任务管理器可以看成工厂,这样可以使用工厂的设计模式(看 wuzhekai1985 大牛里面的设计模式想到的,设计模式C++实现(1)——工厂模式

#任务类
class WatchFunc
{
        virtual void watch(const struct tm& now)=0;
}
class WatchThread:private Thead
{
        vector<WatchFunc *> funcs;        bool wtflag;
        void registerFunc(WatchFunc* func)
        {
                funcs.push_back(func);
                if (!wtflag)
                {
                        wtflag = true;
                        this->start();
                }
        }
        virtual void run()
        {
                cerr<<"WatchThread started"<<endl;
                while (is_running)
                {
                        sleep(60);
                        struct tm now;
                        time_t t;
                        time(&t);
                        localtime_r(&t, &now);
                        for (size_t i=0; i<funcs.size(); i++)
                        {
                                funcs[i]->watch(now);
                        }
                }
        }
}

resgisterFunc函数是初始化各个任务,这样任务会在run里面自动运行。


在各个任务初始化时,需要使用WatchThread对象,多个任务就对应多个任务管理器WatchThead对象,并且还是多个线程,这个跟我的初衷不一样,我只想要一个任务管理器,管理多个任务。

那我们可以使用单例模式,定义一个单例模式的模板类,任务管理器WatchThread继承它。

#单例模式模板类
template <typename T>
class ssingleton
{
protected:
        struct object_creator
        {
                object_creator() { ssingleton<T>::instance(); }
                inline void do_nothing() const { }
        };
        static object_creator create_object;
        ssingleton(){};
public: 
        typedef T object_type;
        static object_type & instance()
        {
                static object_type obj;
                create_object.do_nothing();
                return obj;
        }               
        static object_type& getInstance()
        {
                return instance();
        }
};

template <typename T>
typename ssingleton<T>::object_creator ssingleton<T>::create_object;



现在就差不多了,来看看整体的例子:

template <typename T>
class ssingleton//单例类
{
protected:
        struct object_creator
        {
                object_creator() { ssingleton<T>::instance(); }
                inline void do_nothing() const { }
        };      
        static object_creator create_object;
        ssingleton(){};
public: 
        typedef T object_type;
        static object_type & instance()
        {       
                static object_type obj;
                create_object.do_nothing();
                return obj;
        }               
        static object_type& getInstance()
        {       
                return instance();
        }
};

template <typename T>
typename ssingleton<T>::object_creator ssingleton<T>::create_object;

class WatchFunc//任务父类
{
protected:
        struct tm last_time;
public:
        WatchFunc()
        {
                time_t t = 0;
                localtime_r(&t, &last_time);
        }
        virtual ~WatchFunc()
        {
        
        }
        virtual void watch(const struct tm& now)
        {       
                
        }               
        void updateTime(const struct tm& now)
        {
                last_time = now;
        }
};
class WatchThread : public ssingleton<WatchThread>, private Thread//任务管理器
{
        vector<WatchFunc *> funcs;
        bool wtflag;
        Lock l;
public:
        WatchThread():wtflag(false)
        {
        }
        ~WatchThread()
        {
                for (size_t i=0; i<funcs.size(); i++)
                {
                        delete funcs[i];
                }
        }
        void registerFunc(WatchFunc* func)
        {
                l.lock();
                funcs.push_back(func);
                if (!wtflag)
                {
                        wtflag = true;
                        this->start();
                }
                l.unlock();
        }
        virtual void run()
        {
                cerr<<"WatchThread started"<<endl;
                while (is_running)
                {
                        sleep(60);
                        struct tm now;
                        time_t t;
                        time(&t);
                        localtime_r(&t, &now);
                        for (size_t i=0; i<funcs.size(); i++)
                        {
                                funcs[i]->watch(now);
                        }
                }
        }
private:
};


//定义多个任务类
class A: public WatchFunc
{
	A()
	{
		WatchThread::instance().registerFunc(this);//初始化任务
	}
				
	virtual void watch(const struct tm& now)
        {
        	if (last_time.tm_hour != now.tm_hour)
                {
                	cout << "update A" << endl;
                }
        }
};

class B: public WatchFunc
{
	B()
	{
		WatchThread::instance().registerFunc(this);//初始化任务
	}
				
	virtual void watch(const struct tm& now)
        {
        	if (last_time.tm_hour != now.tm_hour)
                {
                	cout << "update B" << endl;
                }
        }
};

class C: public WatchFunc
{
	A()
	{
		WatchThread::instance().registerFunc(this);//初始化任务
	}
				
	virtual void watch(const struct tm& now)
        {
        	if (last_time.tm_hour != now.tm_hour)
                {
                	cout << "update C" << endl;
                }
        }
};


//定义任务,任务会定时运行(例子是每小时运行一次)
A a;
B b;
C c;


©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页