Method TimerThreadProc

lib/base/timer.cpp:297–355

* Worker thread proc for Timer objects. */

 * Worker thread proc for Timer objects.
 */
void Timer::TimerThreadProc()
{
	namespace ch = std::chrono;

	Log(LogDebug, "Timer", "TimerThreadProc started.");

	Utility::SetThreadName("Timer Thread");

	std::unique_lock<std::mutex> lock (l_TimerMutex);

	for (;;) {
		typedef boost::multi_index::nth_index<TimerSet, 1>::type NextTimerView;
		NextTimerView& idx = boost::get<1>(l_Timers);

		/* Wait until there is at least one timer. */
		while (idx.empty() && !l_StopTimerThread)
			l_TimerCV.wait(lock);

		if (l_StopTimerThread)
			break;

		auto it = idx.begin();

		// timer->~Timer() may be called at any moment (if the last
		// smart pointer gets destroyed) or even already waiting for
		// l_TimerMutex (before doing anything else) which we have
		// locked at the moment. Until our unlock using *timer is safe.
		Timer *timer = *it;

		ch::time_point<ch::system_clock, ch::duration<double>> next (ch::duration<double>(timer->m_Next));

		if (next - ch::system_clock::now() > ch::duration<double>(0.01)) {
			/* Wait for the next timer. */
			l_TimerCV.wait_until(lock, next);

			continue;
		}

		/* Remove the timer from the list so it doesn't get called again
		 * until the current call is completed. */
		l_Timers.erase(timer);

		auto keepAlive (timer->m_Self.lock());

		if (!keepAlive) {
			// The last std::shared_ptr is gone, let ~Timer() proceed
			continue;
		}

		timer->m_Running = true;

		lock.unlock();

		/* Asynchronously call the timer. */
		Utility::QueueAsyncCallback([timer=std::move(keepAlive)]() { timer->Call(); });

		lock.lock();
	}