718 lines
15 KiB
C++
718 lines
15 KiB
C++
|
|
||
|
|
||
|
#include "tthread.h"
|
||
|
#include "tthreadP.h"
|
||
|
|
||
|
#include "boost/thread/thread.hpp"
|
||
|
#include "boost/thread/condition.hpp"
|
||
|
#include "boost/thread/tss.hpp"
|
||
|
#include "boost/thread/xtime.hpp"
|
||
|
#include <queue>
|
||
|
|
||
|
#ifdef WIN32
|
||
|
#include <windows.h>
|
||
|
#define WM_THREAD_NOTIFICATION (WM_USER + 10)
|
||
|
#else
|
||
|
|
||
|
#endif
|
||
|
|
||
|
DEFINE_CLASS_CODE(TThread::Runnable, 21)
|
||
|
|
||
|
//==============================================================================
|
||
|
|
||
|
namespace
|
||
|
{
|
||
|
#ifdef WIN32
|
||
|
HWND MainHandle;
|
||
|
#else
|
||
|
Display *TheDisplay;
|
||
|
Window TheMainWindow;
|
||
|
#endif
|
||
|
|
||
|
//------------------------------------------------------------------------------
|
||
|
|
||
|
class Thread
|
||
|
{
|
||
|
public:
|
||
|
Thread();
|
||
|
Thread(const TThread::RunnableP &runnable);
|
||
|
|
||
|
~Thread();
|
||
|
|
||
|
void join();
|
||
|
void cancel();
|
||
|
|
||
|
#if defined(WIN32) && (_MSC_VER == 1200)
|
||
|
#pragma warning(disable : 4290)
|
||
|
#endif
|
||
|
|
||
|
static void milestone() throw(TThread::Interrupt);
|
||
|
|
||
|
#if defined(WIN32) && (_MSC_VER == 1200)
|
||
|
#pragma warning(default : 4290)
|
||
|
#endif
|
||
|
|
||
|
class Imp;
|
||
|
|
||
|
private:
|
||
|
friend class ThreadGroup;
|
||
|
Imp *m_imp;
|
||
|
};
|
||
|
|
||
|
//------------------------------------------------------------------------------
|
||
|
|
||
|
class ThreadGroup
|
||
|
{
|
||
|
public:
|
||
|
ThreadGroup();
|
||
|
~ThreadGroup();
|
||
|
|
||
|
void add(Thread *thread);
|
||
|
void joinAll();
|
||
|
|
||
|
private:
|
||
|
class Imp;
|
||
|
Imp *m_imp;
|
||
|
};
|
||
|
|
||
|
//------------------------------------------------------------------------------
|
||
|
|
||
|
template <class T>
|
||
|
class QueueT
|
||
|
{
|
||
|
public:
|
||
|
QueueT(int slotCount)
|
||
|
: m_items(), m_slotCount(slotCount), m_notEmpty(), m_notFull(), m_mutex()
|
||
|
{
|
||
|
}
|
||
|
|
||
|
~QueueT() {}
|
||
|
|
||
|
void put(const T &item)
|
||
|
{
|
||
|
TThread::ScopedLock sl(m_mutex);
|
||
|
while (m_items.size() == m_slotCount)
|
||
|
m_notFull.wait(sl);
|
||
|
m_items.push(item);
|
||
|
m_notEmpty.notify_one();
|
||
|
}
|
||
|
|
||
|
T get()
|
||
|
{
|
||
|
TThread::ScopedLock sl(m_mutex);
|
||
|
|
||
|
while (m_items.size() == 0)
|
||
|
m_notEmpty.wait(sl);
|
||
|
|
||
|
m_notFull.notify_one();
|
||
|
T item = m_items.front();
|
||
|
m_items.pop();
|
||
|
return item;
|
||
|
}
|
||
|
|
||
|
int size()
|
||
|
{
|
||
|
TThread::ScopedLock sl(m_mutex);
|
||
|
int size = m_items.size();
|
||
|
return size;
|
||
|
}
|
||
|
|
||
|
private:
|
||
|
std::queue<T> m_items;
|
||
|
TThread::Condition m_notEmpty;
|
||
|
TThread::Condition m_notFull;
|
||
|
TThread::Mutex m_mutex;
|
||
|
int m_slotCount;
|
||
|
};
|
||
|
|
||
|
} // anonymous namespace
|
||
|
|
||
|
//------------------------------------------------------------------------------
|
||
|
|
||
|
void TThread::setMainThreadId(TThread::ThreadInfo *info)
|
||
|
{
|
||
|
assert(info);
|
||
|
#ifdef WIN32
|
||
|
MainHandle = info->mainHandle;
|
||
|
#else
|
||
|
TheDisplay = info->dpy;
|
||
|
TheMainWindow = info->win;
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
//------------------------------------------------------------------------------
|
||
|
|
||
|
#ifdef WIN32
|
||
|
ULONG TThread::getMainShellHandle()
|
||
|
{
|
||
|
return ULONG(MainHandle);
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
//==============================================================================
|
||
|
|
||
|
class BoostRunnable
|
||
|
{
|
||
|
public:
|
||
|
BoostRunnable(const TThread::RunnableP &runnable, Thread::Imp *threadImp)
|
||
|
: m_runnable(runnable), m_threadImp(threadImp) {}
|
||
|
|
||
|
void operator()();
|
||
|
|
||
|
TThread::RunnableP m_runnable;
|
||
|
Thread::Imp *m_threadImp;
|
||
|
};
|
||
|
|
||
|
//==============================================================================
|
||
|
|
||
|
class Thread::Imp
|
||
|
{
|
||
|
public:
|
||
|
Imp() : m_boostThread(0), m_isCanceled(false), m_stateMutex() {}
|
||
|
|
||
|
Imp(const TThread::RunnableP &runnable)
|
||
|
: m_isCanceled(false), m_stateMutex()
|
||
|
{
|
||
|
m_boostThread = new boost::thread(BoostRunnable(runnable, this));
|
||
|
}
|
||
|
|
||
|
~Imp()
|
||
|
{
|
||
|
if (m_boostThread)
|
||
|
delete m_boostThread;
|
||
|
}
|
||
|
|
||
|
boost::thread *m_boostThread;
|
||
|
boost::mutex m_stateMutex;
|
||
|
bool m_isCanceled;
|
||
|
long m_kkkk;
|
||
|
|
||
|
enum State {
|
||
|
Running,
|
||
|
Canceled
|
||
|
};
|
||
|
|
||
|
static boost::mutex m_mutex;
|
||
|
static std::map<long, State> m_state;
|
||
|
|
||
|
class Key
|
||
|
{
|
||
|
public:
|
||
|
Key(long id) : m_id(id) {}
|
||
|
long m_id;
|
||
|
};
|
||
|
|
||
|
static boost::thread_specific_ptr<Key> m_key;
|
||
|
};
|
||
|
|
||
|
boost::mutex Thread::Imp::m_mutex;
|
||
|
std::map<long, Thread::Imp::State> Thread::Imp::m_state;
|
||
|
|
||
|
boost::thread_specific_ptr<Thread::Imp::Key> Thread::Imp::m_key;
|
||
|
|
||
|
void BoostRunnable::operator()()
|
||
|
{
|
||
|
Thread::Imp::m_key.reset(new Thread::Imp::Key(reinterpret_cast<long>(this)));
|
||
|
m_threadImp->m_kkkk = reinterpret_cast<long>(this);
|
||
|
|
||
|
{
|
||
|
boost::mutex::scoped_lock sl(Thread::Imp::m_mutex);
|
||
|
Thread::Imp::m_state[m_threadImp->m_kkkk] = Thread::Imp::Running;
|
||
|
}
|
||
|
|
||
|
assert(m_runnable);
|
||
|
m_runnable->run();
|
||
|
|
||
|
{
|
||
|
boost::mutex::scoped_lock sl(Thread::Imp::m_mutex);
|
||
|
Thread::Imp::m_state.erase(reinterpret_cast<long>(this));
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//==============================================================================
|
||
|
|
||
|
Thread::Thread() : m_imp(new Thread::Imp)
|
||
|
{
|
||
|
}
|
||
|
|
||
|
//------------------------------------------------------------------------------
|
||
|
|
||
|
Thread::Thread(const TThread::RunnableP &runnable)
|
||
|
: m_imp(new Imp(runnable))
|
||
|
{
|
||
|
}
|
||
|
|
||
|
//------------------------------------------------------------------------------
|
||
|
|
||
|
Thread::~Thread()
|
||
|
{
|
||
|
delete m_imp;
|
||
|
}
|
||
|
|
||
|
//------------------------------------------------------------------------------
|
||
|
|
||
|
void Thread::join()
|
||
|
{
|
||
|
assert(m_imp->m_boostThread);
|
||
|
m_imp->m_boostThread->join();
|
||
|
}
|
||
|
|
||
|
//------------------------------------------------------------------------------
|
||
|
|
||
|
void Thread::cancel()
|
||
|
{
|
||
|
boost::mutex::scoped_lock sl(Thread::Imp::m_mutex);
|
||
|
|
||
|
std::map<long, Thread::Imp::State>::iterator it = Thread::Imp::m_state.find(m_imp->m_kkkk);
|
||
|
if (it != Thread::Imp::m_state.end())
|
||
|
Thread::Imp::m_state[m_imp->m_kkkk] = Thread::Imp::Canceled;
|
||
|
}
|
||
|
|
||
|
//------------------------------------------------------------------------------
|
||
|
// static member function
|
||
|
#if defined(WIN32) && (_MSC_VER == 1200)
|
||
|
#pragma warning(disable : 4290)
|
||
|
#endif
|
||
|
|
||
|
void Thread::milestone() throw(TThread::Interrupt)
|
||
|
{
|
||
|
boost::mutex::scoped_lock sl(Thread::Imp::m_mutex);
|
||
|
Thread::Imp::Key key = *Thread::Imp::m_key.get();
|
||
|
Thread::Imp::m_state.find(key.m_id);
|
||
|
|
||
|
if (Thread::Imp::m_state[key.m_id])
|
||
|
throw TThread::Interrupt();
|
||
|
}
|
||
|
|
||
|
#if defined(WIN32) && (_MSC_VER == 1200)
|
||
|
#pragma warning(default : 4290)
|
||
|
#endif
|
||
|
|
||
|
//==============================================================================
|
||
|
|
||
|
class ThreadGroup::Imp
|
||
|
{
|
||
|
public:
|
||
|
Imp() : m_boostThreadGroup() {}
|
||
|
~Imp() {}
|
||
|
|
||
|
boost::thread_group m_boostThreadGroup;
|
||
|
};
|
||
|
|
||
|
ThreadGroup::ThreadGroup() : m_imp(new Imp)
|
||
|
{
|
||
|
}
|
||
|
|
||
|
ThreadGroup::~ThreadGroup()
|
||
|
{
|
||
|
delete m_imp;
|
||
|
}
|
||
|
|
||
|
void ThreadGroup::add(Thread *thread)
|
||
|
{
|
||
|
m_imp->m_boostThreadGroup.add_thread(thread->m_imp->m_boostThread);
|
||
|
}
|
||
|
|
||
|
void ThreadGroup::joinAll()
|
||
|
{
|
||
|
m_imp->m_boostThreadGroup.join_all();
|
||
|
}
|
||
|
|
||
|
//==============================================================================
|
||
|
|
||
|
#if defined(WIN32) && (_MSC_VER == 1200)
|
||
|
#pragma warning(disable : 4290)
|
||
|
#endif
|
||
|
|
||
|
void TThread::milestone() throw(TThread::Interrupt)
|
||
|
{
|
||
|
Thread::milestone();
|
||
|
}
|
||
|
|
||
|
#if defined(WIN32) && (_MSC_VER == 1200)
|
||
|
#pragma warning(default : 4290)
|
||
|
#endif
|
||
|
|
||
|
//==============================================================================
|
||
|
|
||
|
class TThread::Mutex::Imp
|
||
|
{
|
||
|
public:
|
||
|
boost::mutex m_mutex;
|
||
|
|
||
|
Imp() : m_mutex() {}
|
||
|
~Imp() {}
|
||
|
};
|
||
|
|
||
|
TThread::Mutex::Mutex() : m_imp(new Imp)
|
||
|
{
|
||
|
}
|
||
|
|
||
|
TThread::Mutex::~Mutex()
|
||
|
{
|
||
|
delete m_imp;
|
||
|
}
|
||
|
|
||
|
//==============================================================================
|
||
|
|
||
|
class TThread::ScopedLock::Imp
|
||
|
{
|
||
|
public:
|
||
|
boost::mutex::scoped_lock *m_sl;
|
||
|
|
||
|
Imp(boost::mutex &mutex) : m_sl(new boost::mutex::scoped_lock(mutex)) {}
|
||
|
|
||
|
~Imp()
|
||
|
{
|
||
|
m_sl->unlock();
|
||
|
delete m_sl;
|
||
|
}
|
||
|
};
|
||
|
|
||
|
TThread::ScopedLock::ScopedLock(Mutex &mutex) : m_imp(new Imp(mutex.m_imp->m_mutex)) {}
|
||
|
|
||
|
TThread::ScopedLock::~ScopedLock()
|
||
|
{
|
||
|
delete m_imp;
|
||
|
}
|
||
|
|
||
|
//==============================================================================
|
||
|
|
||
|
class TThread::Condition::Imp
|
||
|
{
|
||
|
public:
|
||
|
boost::condition m_condition;
|
||
|
|
||
|
Imp() : m_condition() {}
|
||
|
~Imp() {}
|
||
|
};
|
||
|
|
||
|
TThread::Condition::Condition()
|
||
|
: m_imp(new Imp()) {}
|
||
|
|
||
|
TThread::Condition::~Condition()
|
||
|
{
|
||
|
delete m_imp;
|
||
|
}
|
||
|
|
||
|
void TThread::Condition::wait(ScopedLock &lock)
|
||
|
{
|
||
|
m_imp->m_condition.wait(*(lock.m_imp->m_sl));
|
||
|
}
|
||
|
|
||
|
bool TThread::Condition::wait(ScopedLock &lock, long timeout)
|
||
|
{
|
||
|
boost::xtime xt;
|
||
|
boost::xtime_get(&xt, boost::TIME_UTC);
|
||
|
xt.nsec += timeout * 1000;
|
||
|
xt.sec += timeout / 1000;
|
||
|
return m_imp->m_condition.timed_wait(*(lock.m_imp->m_sl), xt);
|
||
|
}
|
||
|
|
||
|
void TThread::Condition::notifyOne()
|
||
|
{
|
||
|
m_imp->m_condition.notify_one();
|
||
|
}
|
||
|
|
||
|
void TThread::Condition::notifyAll()
|
||
|
{
|
||
|
m_imp->m_condition.notify_all();
|
||
|
}
|
||
|
|
||
|
//==============================================================================
|
||
|
|
||
|
TThread::Msg::Msg()
|
||
|
{
|
||
|
}
|
||
|
|
||
|
//------------------------------------------------------------------------------
|
||
|
|
||
|
void TThread::Msg::send()
|
||
|
{
|
||
|
Msg *msg = clone();
|
||
|
|
||
|
#ifdef WIN32
|
||
|
/*
|
||
|
Non viene utilizzato PostThreadMessage perche' se l'applicazione
|
||
|
si trova in un modal loop (esempio MessageBox) oppure si sta
|
||
|
facendo move o resize di una finestra i messaggi non giungono al
|
||
|
message loop.
|
||
|
http://support.microsoft.com/default.aspx?scid=KB;EN-US;q183116&
|
||
|
*/
|
||
|
|
||
|
/*
|
||
|
BOOL rc = PostThreadMessage(
|
||
|
getMainThreadId(), // thread identifier
|
||
|
WM_THREAD_NOTIFICATION, // message
|
||
|
WPARAM(msg), // first message parameter
|
||
|
0); // second message parameter
|
||
|
*/
|
||
|
PostMessage(HWND(getMainShellHandle()), WM_THREAD_NOTIFICATION, WPARAM(msg), 0);
|
||
|
#else
|
||
|
XClientMessageEvent clientMsg;
|
||
|
clientMsg.type = ClientMessage;
|
||
|
clientMsg.window = TheMainWindow;
|
||
|
clientMsg.format = 32;
|
||
|
clientMsg.message_type = Msg::MsgId();
|
||
|
clientMsg.data.l[0] = (long)msg;
|
||
|
//Status status =
|
||
|
XSendEvent(TheDisplay, TheMainWindow, 0, NoEventMask, (XEvent *)&clientMsg);
|
||
|
XFlush(TheDisplay);
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
//------------------------------------------------------------------------------
|
||
|
|
||
|
// statica
|
||
|
UINT TThread::Msg::MsgId()
|
||
|
{
|
||
|
#ifdef WIN32
|
||
|
return WM_THREAD_NOTIFICATION;
|
||
|
#else
|
||
|
static Atom atom = 0;
|
||
|
if (!atom) {
|
||
|
atom = XInternAtom(TheDisplay, "ThreadMessage", false);
|
||
|
assert(atom);
|
||
|
}
|
||
|
return atom;
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
//==============================================================================
|
||
|
|
||
|
class TThread::Executor::Imp : public TSmartObject
|
||
|
{
|
||
|
public:
|
||
|
typedef TSmartPointerT<TThread::Executor::Imp> ImpP;
|
||
|
|
||
|
//---------------------------------------------------
|
||
|
|
||
|
class Worker : public Runnable
|
||
|
{
|
||
|
public:
|
||
|
Worker(ImpP owner) : Runnable(), m_owner(owner) {}
|
||
|
~Worker() {}
|
||
|
|
||
|
void run();
|
||
|
void doCleanup();
|
||
|
|
||
|
ImpP m_owner;
|
||
|
};
|
||
|
|
||
|
//---------------------------------------------------
|
||
|
|
||
|
bool m_suspend;
|
||
|
bool m_threadHasToDie;
|
||
|
|
||
|
UINT m_threadCount;
|
||
|
Mutex m_mutex;
|
||
|
|
||
|
Condition m_cond;
|
||
|
Condition m_taskQueueEmpty;
|
||
|
|
||
|
//------
|
||
|
Condition m_taskQueueNotEmpty;
|
||
|
//------
|
||
|
|
||
|
std::queue<TThread::RunnableP> m_tasks;
|
||
|
std::map<long, Thread *> m_workerThreads;
|
||
|
|
||
|
Imp(int threadsCount, bool suspend)
|
||
|
: TSmartObject(), m_suspend(suspend), m_threadHasToDie(false), m_threadCount(threadsCount), m_tasks(), m_workerThreads(), m_mutex(), m_cond(){};
|
||
|
|
||
|
~Imp()
|
||
|
{
|
||
|
}
|
||
|
};
|
||
|
|
||
|
//------------------------------------------------------------------------------
|
||
|
|
||
|
TThread::Executor::Executor(int threadsCount, bool suspend) : m_imp(new Imp(threadsCount, suspend))
|
||
|
{
|
||
|
m_imp->addRef();
|
||
|
}
|
||
|
|
||
|
//------------------------------------------------------------------------------
|
||
|
|
||
|
TThread::Executor::~Executor()
|
||
|
{
|
||
|
{
|
||
|
TThread::ScopedLock sl(m_imp->m_mutex);
|
||
|
|
||
|
if (m_imp->m_suspend) {
|
||
|
m_imp->m_threadHasToDie = true;
|
||
|
m_imp->m_taskQueueNotEmpty.notifyAll();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
m_imp->release();
|
||
|
}
|
||
|
|
||
|
//------------------------------------------------------------------------------
|
||
|
|
||
|
void TThread::Executor::Imp::Worker::run()
|
||
|
{
|
||
|
try {
|
||
|
while (true) {
|
||
|
// check if thread has been canceled
|
||
|
Thread::milestone();
|
||
|
|
||
|
// get the next task
|
||
|
RunnableP task = 0;
|
||
|
|
||
|
{
|
||
|
ScopedLock sl(m_owner->m_mutex);
|
||
|
if (m_owner->m_tasks.empty()) {
|
||
|
// la lista di task e' stata esaurita
|
||
|
if (m_owner->m_suspend) {
|
||
|
// il thread deve sospendersi
|
||
|
m_owner->m_taskQueueNotEmpty.wait(sl);
|
||
|
|
||
|
// a questo punto il thread e' stato risvegliato
|
||
|
if (m_owner->m_threadHasToDie) {
|
||
|
doCleanup();
|
||
|
return;
|
||
|
}
|
||
|
} else {
|
||
|
// il thread sta per morire -> bisogna eliminarlo dalla lista dei worker thread
|
||
|
doCleanup();
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if (!m_owner->m_tasks.empty()) {
|
||
|
task = m_owner->m_tasks.front();
|
||
|
m_owner->m_tasks.pop();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if (task)
|
||
|
task->run();
|
||
|
|
||
|
// check if thread has been canceled
|
||
|
Thread::milestone();
|
||
|
}
|
||
|
} catch (TThread::Interrupt &) {
|
||
|
//m_owner->m_cond.notifyOne();
|
||
|
} catch (...) {
|
||
|
|
||
|
// eccezione non prevista --> bisogna eliminare il thread
|
||
|
// dalla lista dei worker thread
|
||
|
|
||
|
ScopedLock sl(m_owner->m_mutex);
|
||
|
doCleanup();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//------------------------------------------------------------------------------
|
||
|
|
||
|
void TThread::Executor::Imp::Worker::doCleanup()
|
||
|
{
|
||
|
std::map<long, Thread *>::iterator it = m_owner->m_workerThreads.find(reinterpret_cast<long>(this));
|
||
|
|
||
|
if (it != m_owner->m_workerThreads.end()) {
|
||
|
Thread *thread = it->second;
|
||
|
delete thread;
|
||
|
m_owner->m_workerThreads.erase(it);
|
||
|
}
|
||
|
|
||
|
if (m_owner->m_workerThreads.size() == 0)
|
||
|
m_owner->m_taskQueueEmpty.notifyAll();
|
||
|
}
|
||
|
|
||
|
//------------------------------------------------------------------------------
|
||
|
|
||
|
void TThread::Executor::addTask(const RunnableP &task)
|
||
|
{
|
||
|
TThread::ScopedLock sl(m_imp->m_mutex);
|
||
|
m_imp->m_tasks.push(task);
|
||
|
if (m_imp->m_workerThreads.size() < m_imp->m_threadCount) {
|
||
|
TThread::Executor::Imp::Worker *worker =
|
||
|
new TThread::Executor::Imp::Worker(m_imp);
|
||
|
|
||
|
m_imp->m_workerThreads[reinterpret_cast<long>(worker)] = new Thread(worker);
|
||
|
} else {
|
||
|
if (m_imp->m_suspend)
|
||
|
// risveglia uno dei thread in attesa
|
||
|
m_imp->m_taskQueueNotEmpty.notifyOne();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//------------------------------------------------------------------------------
|
||
|
|
||
|
void TThread::Executor::clear()
|
||
|
{
|
||
|
ScopedLock sl(m_imp->m_mutex);
|
||
|
|
||
|
while (!m_imp->m_tasks.empty())
|
||
|
m_imp->m_tasks.pop();
|
||
|
}
|
||
|
|
||
|
//------------------------------------------------------------------------------
|
||
|
|
||
|
void TThread::Executor::cancel()
|
||
|
{
|
||
|
{
|
||
|
ScopedLock sl(m_imp->m_mutex);
|
||
|
|
||
|
while (!m_imp->m_tasks.empty())
|
||
|
m_imp->m_tasks.pop();
|
||
|
}
|
||
|
|
||
|
while (true) {
|
||
|
Thread *thread = 0;
|
||
|
{
|
||
|
ScopedLock sl(m_imp->m_mutex);
|
||
|
if (m_imp->m_workerThreads.empty())
|
||
|
break;
|
||
|
else {
|
||
|
std::map<long, Thread *>::iterator it = m_imp->m_workerThreads.begin();
|
||
|
thread = it->second;
|
||
|
m_imp->m_workerThreads.erase(it);
|
||
|
|
||
|
if (thread)
|
||
|
thread->cancel();
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//------------------------------------------------------------------------------
|
||
|
|
||
|
void TThread::Executor::wait()
|
||
|
{
|
||
|
TThread::ScopedLock sl(m_imp->m_mutex);
|
||
|
|
||
|
while (m_imp->m_workerThreads.size())
|
||
|
m_imp->m_taskQueueEmpty.wait(sl);
|
||
|
}
|
||
|
|
||
|
//------------------------------------------------------------------------------
|
||
|
|
||
|
bool TThread::Executor::wait(long timeout)
|
||
|
{
|
||
|
TThread::ScopedLock sl(m_imp->m_mutex);
|
||
|
|
||
|
bool expired = false;
|
||
|
while (m_imp->m_workerThreads.size())
|
||
|
expired = m_imp->m_taskQueueEmpty.wait(sl, timeout);
|
||
|
|
||
|
return expired;
|
||
|
}
|
||
|
|
||
|
//------------------------------------------------------------------------------
|
||
|
|
||
|
int TThread::Executor::getThreadCount()
|
||
|
{
|
||
|
TThread::ScopedLock sl(m_imp->m_mutex);
|
||
|
return m_imp->m_workerThreads.size();
|
||
|
}
|
||
|
|
||
|
//------------------------------------------------------------------------------
|
||
|
|
||
|
int TThread::Executor::getTaskCount()
|
||
|
{
|
||
|
TThread::ScopedLock sl(m_imp->m_mutex);
|
||
|
return m_imp->m_tasks.size();
|
||
|
}
|