1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
|
//
// TaskManager.h
//
// Library: Foundation
// Package: Tasks
// Module: Tasks
//
// Definition of the TaskManager class.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_TaskManager_INCLUDED
#define Foundation_TaskManager_INCLUDED
#include "Poco/Foundation.h"
#include "Poco/Mutex.h"
#include "Poco/Task.h"
#include "Poco/AutoPtr.h"
#include "Poco/NotificationCenter.h"
#include "Poco/Timestamp.h"
#include <list>
namespace Poco {
class Notification;
class ThreadPool;
class Exception;
class Foundation_API TaskManager
/// The TaskManager manages a collection of tasks
/// and monitors their lifetime.
///
/// A TaskManager has a built-in NotificationCenter that
/// is used to send out notifications on task progress
/// and task states. See the TaskNotification class and its
/// subclasses for the various events that result in a notification.
/// To keep the number of notifications small, a TaskProgressNotification
/// will only be sent out once in 100 milliseconds.
{
public:
using TaskPtr = AutoPtr<Task>;
using TaskList = std::list<TaskPtr>;
TaskManager(const std::string& name = "",
int minCapacity = 2,
int maxCapacity = 16,
int idleTime = 60,
int stackSize = POCO_THREAD_STACK_SIZE);
/// Creates the TaskManager.
TaskManager(ThreadPool& pool);
/// Creates the TaskManager, using the
/// given ThreadPool (should be used
/// by this TaskManager exclusively).
~TaskManager();
/// Destroys the TaskManager.
bool start(Task* pTask);
/// Starts the given task in a thread obtained
/// from the thread pool; returns true if successful.
///
/// If this method returns false, the task was cancelled
/// before it could be started, or it was already running;
/// in any case, a false return means refusal of ownership
/// and indicates that the task pointer may not be valid
/// anymore (it will only be valid if it was duplicated
/// prior to this call).
///
/// The TaskManager takes ownership of the Task object
/// and deletes it when it is finished.
void cancelAll();
/// Requests cancellation of all tasks.
void joinAll();
/// Waits for the completion of all the threads
/// in the TaskManager's thread pool.
///
/// Note: joinAll() will wait for ALL tasks in the
/// TaskManager's ThreadPool to complete. If the
/// ThreadPool has threads created by other
/// facilities, these threads must also complete
/// before joinAll() can return.
TaskList taskList() const;
/// Returns a copy of the internal task list.
int count() const;
/// Returns the number of tasks in the internal task list.
void addObserver(const AbstractObserver& observer);
/// Registers an observer with the NotificationCenter.
/// Usage:
/// Observer<MyClass, MyNotification> obs(*this, &MyClass::handleNotification);
/// notificationCenter.addObserver(obs);
void removeObserver(const AbstractObserver& observer);
/// Unregisters an observer with the NotificationCenter.
static const int MIN_PROGRESS_NOTIFICATION_INTERVAL;
protected:
void postNotification(const Notification::Ptr& pNf);
/// Posts a notification to the task manager's
/// notification center.
void taskStarted(Task* pTask);
void taskProgress(Task* pTask, float progress);
void taskCancelled(Task* pTask);
void taskFinished(Task* pTask);
void taskFailed(Task* pTask, const Exception& exc);
private:
using MutexT = FastMutex;
using ScopedLockT = MutexT::ScopedLock;
ThreadPool& _threadPool;
bool _ownPool;
TaskList _taskList;
Timestamp _lastProgressNotification;
NotificationCenter _nc;
mutable MutexT _mutex;
friend class Task;
};
//
// inlines
//
inline int TaskManager::count() const
{
ScopedLockT lock(_mutex);
return (int) _taskList.size();
}
} // namespace Poco
#endif // Foundation_TaskManager_INCLUDED
|
