C++ Dispatcher::addTask方法代码示例

int main(int argc, char* argv[])
{
	// Setup bad allocation handler
	std::set_new_handler(badAllocationHandler);

#ifndef _WIN32
	// ignore sigpipe...
	struct sigaction sigh;
	sigh.sa_handler = SIG_IGN;
	sigh.sa_flags = 0;
	sigemptyset(&sigh.sa_mask);
	sigaction(SIGPIPE, &sigh, nullptr);
#endif

	ServiceManager servicer;

	g_dispatcher.start();
	g_scheduler.start();

	g_dispatcher.addTask(createTask(std::bind(mainLoader, argc, argv, &servicer)));

	g_loaderSignal.wait(g_loaderUniqueLock);

	if (servicer.is_running()) {
		std::cout << ">> " << g_config.getString(ConfigManager::SERVER_NAME) << " Server Online!" << std::endl << std::endl;
#ifdef _WIN32
		SetConsoleCtrlHandler([](DWORD) -> BOOL {
			g_dispatcher.addTask(createTask([]() {
				g_dispatcher.addTask(createTask(
					std::bind(&Game::shutdown, &g_game)
				));
				g_scheduler.stop();
				g_databaseTasks.stop();
				g_dispatcher.stop();
			}));
			ExitThread(0);
		}, 1);
#endif
		servicer.run();
		g_scheduler.join();
		g_databaseTasks.join();
		g_dispatcher.join();
	} else {
		std::cout << ">> No services running. The server is NOT online." << std::endl;
		g_dispatcher.addTask(createTask([]() {
			g_dispatcher.addTask(createTask([]() {
				g_scheduler.shutdown();
				g_databaseTasks.shutdown();
				g_dispatcher.shutdown();
			}));
			g_scheduler.stop();
			g_databaseTasks.stop();
			g_dispatcher.stop();
		}));
		g_scheduler.join();
		g_databaseTasks.join();
		g_dispatcher.join();
	}
	return 0;
}

void Signals::dispatchSignalHandler(int signal)
{
	switch(signal) {
		case SIGINT: //Shuts the server down
			g_dispatcher.addTask(createTask(sigintHandler));
			break;
		case SIGTERM: //Shuts the server down
			g_dispatcher.addTask(createTask(sigtermHandler));
			break;
#ifndef _WIN32
		case SIGHUP: //Reload config/data
			g_dispatcher.addTask(createTask(sighupHandler));
			break;
		case SIGUSR1: //Saves game state
			g_dispatcher.addTask(createTask(sigusr1Handler));
			break;
#endif
		default:
			break;
	}
}

int main(int argc, char* argv[])
{
    // Setup bad allocation handler
    std::set_new_handler(badAllocationHandler);

#ifndef WIN32
    // ignore sigpipe...
    struct sigaction sigh;
    sigh.sa_handler = SIG_IGN;
    sigh.sa_flags = 0;
    sigemptyset(&sigh.sa_mask);
    sigaction(SIGPIPE, &sigh, NULL);
#endif

    ServiceManager servicer;

    g_dispatcher.start();
    g_scheduler.start();

    g_dispatcher.addTask(createTask(boost::bind(mainLoader, argc, argv, &servicer)));

    g_loaderSignal.wait(g_loaderUniqueLock);

    if (servicer.is_running()) {
        std::cout << ">> " << g_config.getString(ConfigManager::SERVER_NAME) << " Server Online!" << std::endl << std::endl;
        servicer.run();
        g_scheduler.join();
        g_dispatcher.join();
    } else {
        std::cout << ">> No services running. The server is NOT online." << std::endl;
        g_scheduler.stop();
        g_dispatcher.stop();
        g_dispatcher.addTask(createTask(boost::bind(shutdown)));
        g_scheduler.join();
        g_dispatcher.join();
    }
    return 0;
}

void DatabaseTasks::runTask(const DatabaseTask& task)
{
	bool success;
	DBResult_ptr result;
	if (task.store) {
		result = db.storeQuery(task.query);
		success = true;
	} else {
		result = nullptr;
		success = db.executeQuery(task.query);
	}

	if (task.callback) {
		g_dispatcher.addTask(createTask(std::bind(task.callback, result, success)));
	}
}

void Scheduler::schedulerThread()
{
	srand(time(NULL));

	Dispatcher *dispatcher = Dispatcher::instance();

	boost::unique_lock<boost::mutex> eventLockUnique(m_eventLock, boost::defer_lock);

	while(m_threadState != STATE_TERMINATED) {
		SchedulerTask* task = NULL;
		bool runTask = false;
		bool ret = true;

		eventLockUnique.lock();

		if(m_eventList.empty()) {
			m_eventSignal.wait(eventLockUnique);
		} else {
			ret = m_eventSignal.timed_wait(eventLockUnique, m_eventList.top()->getCycle());
		}

		if(ret == false && (m_threadState != STATE_TERMINATED)) {
			task = m_eventList.top();
			m_eventList.pop();

			EventIdSet::iterator it = m_eventIds.find(task->getEventId());
			if(it != m_eventIds.end()) {
				runTask = true;
				m_eventIds.erase(it);
			}
		}

		eventLockUnique.unlock();

		if(task) {
			if(runTask) {
				task->setDontExpire();
				dispatcher->addTask(task);
			} else {
				delete task;
			}
		}
	}
}

int LuaBinder::luaDispatcherAddTask(lua_State* L)
{
	// Dispatcher.addTask(callable, ...)
	int parameters = lua_gettop(L);
	if (lua_isfunction(L, -parameters/*1*/)) {
		LuaEventObject* eventDesc = new LuaEventObject();
		for (int i = 0; i < parameters - 1; ++i) {
			eventDesc->parameters.push_back(luaL_ref(L, LUA_REGISTRYINDEX));
		}

		eventDesc->function = luaL_ref(L, LUA_REGISTRYINDEX);

		g_dispatcher.addTask(createTask(std::bind(&LuaBinder::executeLuaEvent, L, eventDesc)));
		LuaBinder::pushBoolean(L, true);
	} else {
		LuaBinder::reportError("[Error - Scheduler.addTask] Callable(#arg 1) must be function.");
		LuaBinder::pushBoolean(L, false);
	}

	return 1;
}

void OutputMessagePool::releaseMessage(OutputMessage* msg)
{
	g_dispatcher.addTask(
		createTask(boost::bind(&OutputMessagePool::internalReleaseMessage, this, msg)));
}