Method ThreadMain

core/logic/Database.cpp:439–487

}

void DBManager::ThreadMain()
{
	std::unique_lock<std::mutex> lock(m_Lock);

	while (true) {
		// The lock has been acquired. Grab everything we can out of the
		// queue. Since we want to flush the queue even if we're terminated,
		// we process all operations we can before checking to terminate.
		// There's no risk of starvation since the main thread blocks on us
		// terminating.
		auto queue = &m_OpQueue.GetLikelyQueue();
		if (queue->empty()) {
			// If the queue is empty and we've been asked to stop, leave now.
			if (m_Terminate)
				return;

			// Otherwise, wait for something to happen.
			m_QueueEvent.wait(lock);
			continue;
		}

		IDBThreadOperation *op = queue->first();
		queue->pop();

		// Unlock the queue when we run the query, so the main thread can
		// keep pumping events. We re-acquire the lock to check for more
		// items. It's okay if we terminate while unlocked; the main
		// thread would be blocked and we'd need to flush the queue
		// anyway, so after we've depleted the queue here, we'll just
		// reach the terminate at the top of the loop.
		lock.unlock();
		op->RunThreadPart();

		// Re-acquire the lock and give the data back to the main thread
		// immediately. We use a separate lock to minimize game thread
		// contention.
		{
			std::lock_guard<std::mutex> think_lock(m_ThinkLock);
			m_ThinkQueue.push(op);
		}

		// Note that we add a 20ms delay after processing a query. This is
		// questionable but the intent is to avoid starving the game thread.
		if (!m_Terminate)
			std::this_thread::sleep_for(20ms);

		lock.lock();
	}
}

void DBManager::RunFrame()
{