Poco库使用:任务管理器TaskManager

Poco库的任务管理器TaskManager有点像一个功能更加强大的线程池。我们定义的每一个Task以线程的形式运行在TaskManager中。TaskManager负责对运行的每个线程任务进行管理和监控。这里介绍一下任务管理器的用法。

1.定义独立任务

运行在TaskManager中的任务需要继承自Task类。我们可以给每个任务指定固定的名称。除了使用TaskManager对任务进行管理外，我们还可以将Task放到独立的线程中运行。为了方便外部的管理我们通过Task的setProgress()方法来控制任务的进度。

class TestTask : public Task
{
public:
	TestTask() : Task("TestTask")
	{
	}
	void runTask()
	{
		_event.wait();
		if (sleep(10))
              return;
           //设置任务的进度   
		setProgress(0.5);
		_event.wait();
           //判断任务是否取消了
		if (isCancelled())
			return;
           //设置任务进度
		setProgress(1.0);
		_event.wait();
	}
	void cont()
	{
       _event.set();
	}
private:
    //通过事件来对任务进行控制
	Event _event;
};

void testFinish()
{
    //定义任务
	AutoPtr<TestTask> pTT = new TestTask;
    //开闭线程运行任务
	Thread thr;
	thr.start(*pTT);
   //控制任务的进度
	pTT->cont();
	while (pTT->progress() != 0.5) Thread::sleep(50);
   //取消任务
	pTT->cancel();
	//等待线程结束
	thr.join();
  //除了判断进度外我们还可以通过pTT->state()来查看任务状态
  //常用的状态包括:
  //Task::TASK_RUNNING     任务运行中
  //Task::TASK_CANCELLING  任务取消
  //Task::TASK_IDLE        任务空闲
  //Task::TASK_FINISHED    任务结束
}

2.使用TaskManager启动多个任务

class SimpleTask : public Task
{
public:
	SimpleTask() : Task("SimpleTask")
	{
	}
	void runTask()
	{
		sleep(10000);
	}
};
int main(int argc, char** argv)
{
    //启动任务
	TaskManager tm;
	tm.start(new SimpleTask);
	tm.start(new SimpleTask);
	tm.start(new SimpleTask);

    //结束任务
	TaskManager::TaskList list = tm.taskList();
	tm.cancelAll();
	while (tm.count() > 0) Thread::sleep(100);
}

3.TaskManager使用自定义线程池

通过引入自定义的线程池，我们可以对任务管理器中任务执行数量进行管理。

class SimpleTask : public Task
{
public:
	SimpleTask() : Task("SimpleTask")
	{
	}

	void runTask()
	{
       sleep(10000);
	}
};
int main(int argc, char** argv)
{
    //最小线程数为2 最大线程数为5 线程的闲置时间为120s
	ThreadPool  tp(2, 5, 120);
	TaskManager tm(tp);
   //将线程池填充满
	for (int i = 0; i < tp.capacity(); ++i)
	{
		tm.start(new SimpleTask);
	}
   //线程池和任务管理器任务数量的关系
	//tp.allocated() == tp.capacity()
	//tm.count() == tp.allocated()
   //等待线程结束
	tp.joinAll();
}

4.添加任务观察者

通过给任务管理器TaskManager添加观察者TaskObserver，我们可以对任务管理器中的任务运行状态进行监控。监控的内容包括:
1.任务是否启动
2.任务是否结束
3.任务进度
4.任务是否失败

namespace
{
	class TestTask : public Task
	{
	public:
		TestTask() :
			Task("TestTask"),
			_fail(false)
		{
		}

		void runTask()
		{
			_event.wait();
			setProgress(0.5);
			_event.wait();
			if (isCancelled())
				return;
			if (_fail)
				throw SystemException("warp core breach detected");
			setProgress(1.0);
			_event.wait();
		}

		void fail()
		{
			_fail = true;
		}

		void cont()
		{
			_event.set();
		}

	private:
		Event _event;
		bool  _fail;
	};

	class TaskObserver
	{
	public:
		TaskObserver() :
			_started(false),
			_cancelled(false),
			_finished(false),
			_pException(0),
			_progress(0.0)
		{
		}

		~TaskObserver()
		{
			delete _pException;
		}

		void taskStarted(TaskStartedNotification* pNf)
		{
			_started = true;
			pNf->release();
		}

		void taskCancelled(TaskCancelledNotification* pNf)
		{
			_cancelled = true;
			pNf->release();
		}

		void taskFinished(TaskFinishedNotification* pNf)
		{
			_finished = true;
			pNf->release();
		}

		void taskFailed(TaskFailedNotification* pNf)
		{
			_pException = pNf->reason().clone();
			pNf->release();
		}

		void taskProgress(TaskProgressNotification* pNf)
		{
			_progress = pNf->progress();
			pNf->release();
		}

		bool started() const
		{
			return _started;
		}

		bool cancelled() const
		{
			return _cancelled;
		}

		bool finished() const
		{
			return _finished;
		}

		float progress() const
		{
			return _progress;
		}

		Exception* error() const
		{
			return _pException;
		}

	private:
		std::atomic<bool> _started;
		std::atomic<bool> _cancelled;
		std::atomic<bool> _finished;
		Exception*        _pException;
		float             _progress;
	};

}

int main(int argc, char** argv)
{
	//添加不同任务状态的观察函数
	TaskManager task_manager;
	TaskObserver task_observer;
	task_manager.addObserver(Observer<TaskObserver, TaskStartedNotification>(task_observer, &TaskObserver::taskStarted));
	task_manager.addObserver(Observer<TaskObserver, TaskCancelledNotification>(task_observer, &TaskObserver::taskCancelled));
	task_manager.addObserver(Observer<TaskObserver, TaskFailedNotification>(task_observer, &TaskObserver::taskFailed));
	task_manager.addObserver(Observer<TaskObserver, TaskFinishedNotification>(task_observer, &TaskObserver::taskFinished));
	task_manager.addObserver(Observer<TaskObserver, TaskProgressNotification>(task_observer, &TaskObserver::taskProgress));

   //启动任务 
	AutoPtr<TestTask> pTT = new TestTask;
	task_manager.start(pTT.duplicate());
	Thread::sleep(200);
	pTT->cont();
	while (pTT->progress() != 0.5) Thread::sleep(50);
	//progress() == 0.5
	//state() == Task::TASK_RUNNING
	TaskManager::TaskList list = task_manager.taskList();
	while (task_manager.count() == 1) Thread::sleep(50);
   //取消任务
   task_manager.cancelAll();
	bool is_canceled = task_observer.cancelled();
   //使任务失败结束
   pTT->fail();
   pTT->cont();
}

5.使用自定义的任务观察者和任务通知

为了在任务监控过程中传递更多的信息，实现更加细致化的监控，我们可以自定义任务观察者和任务通知。将更多的任务信息传递出来。自定义任务观察者和任务消息的实现方法如下:

namespace
{
    //通过模板指定消息内容形式
	template <typename T>
	class CustomNotificationTask : public Task
	{
	public:
		CustomNotificationTask(const T& t) :
			Task("CustomNotificationTask"),
			_custom(t)
		{
		}

		void runTask()
		{
			sleep(10000);
		}
           //设置自定义消息 
		void setCustom(const T& custom)
		{
			_custom = custom;
			postNotification(new TaskCustomNotification<T>(this, _custom));
		}

	private:
		T _custom;
	};


	template <class C>
	class CustomTaskObserver
	{
	public:
		CustomTaskObserver(const C& custom) : _custom(custom)
		{
		}

		~CustomTaskObserver()
		{
		}

		void taskCustom(TaskCustomNotification<C>* pNf)
		{
			_custom = pNf->custom();
			pNf->release();
		}

		const C& custom() const
		{
			return _custom;
		}

	private:
		C _custom;
	};
}

int main(int argc, char** argv)
{
	TaskManager task_manager;
   //添加类型为int的自定义观察者 
	CustomTaskObserver<int> ti(0);
	task_manager.addObserver(Observer<CustomTaskObserver<int>, TaskCustomNotification<int> >
		(ti, &CustomTaskObserver<int>::taskCustom));
    //执行自定义任务
	AutoPtr<CustomNotificationTask<int> > pCNT1 = new CustomNotificationTask<int>(0);
	task_manager.start(pCNT1.duplicate());
   
   //设置任务消息
	for (int i = 1; i < 10; ++i)
	{
		pCNT1->setCustom(i);
	}
   //添加类型为string的自定义观察者 
	CustomTaskObserver<std::string> ts("");
	task_manager.addObserver(Observer<CustomTaskObserver<std::string>, TaskCustomNotification<std::string> >
		(ts, &CustomTaskObserver<std::string>::taskCustom));
	AutoPtr<CustomNotificationTask<std::string> > pCNT2 = new CustomNotificationTask<std::string>("");
	task_manager.start(pCNT2.duplicate());
	std::string str("notify me");
	pCNT2->setCustom(str);
}