Esempi in C++ (Cpp) per THREAD_MUTEX_DELETE

Esempio n. 1

File: log.cpp Progetto: ruleless/cill

void Log::finalise()
{
    if (!mInited)
        return;

    mbExit = true;
    THREAD_SINGNAL_SET(mCond);
#if PLATFORM == PLATFORM_WIN32
    ::WaitForSingleObject(mTid, INFINITE);
    ::CloseHandle(mTid);
#else
    pthread_join(mTid, NULL);
#endif

    mOutlist = mInlist;
    _flushOutlist();

    THREAD_SINGNAL_DELETE(mCond);
    THREAD_MUTEX_DELETE(mMutex);

    mLogPrinter.clear();

    mInited = false;
}

Esempio n. 2

File: threadpool.hpp Progetto: MapleEve/kbengine

	virtual void deleteMutex(void)
	{
		THREAD_MUTEX_DELETE(mutex_);
	}

Esempio n. 3

//-------------------------------------------------------------------------------------
void ThreadPool::destroy()
{
    isDestroyed_ = true;

    THREAD_MUTEX_LOCK(threadStateList_mutex_);

    DEBUG_MSG(fmt::format("ThreadPool::destroy(): starting size {0}.\n",
                          allThreadList_.size()));

    THREAD_MUTEX_UNLOCK(threadStateList_mutex_);

    int itry = 0;
    while(true)
    {
        KBEngine::sleep(300);
        itry++;

        std::string taskaddrs = "";
        THREAD_MUTEX_LOCK(threadStateList_mutex_);

        int count = allThreadList_.size();
        std::list<TPThread*>::iterator itr = allThreadList_.begin();
        for(; itr != allThreadList_.end(); itr++)
        {
            if((*itr))
            {
                if((*itr)->state() != TPThread::THREAD_STATE_END)
                {
                    (*itr)->sendCondSignal();
                    taskaddrs += (fmt::format("{0:p},", (void*)(*itr)));
                }
                else
                {
                    count--;
                }
            }
        }

        THREAD_MUTEX_UNLOCK(threadStateList_mutex_);

        if(count <= 0)
        {
            break;
        }
        else
        {
            WARNING_MSG(fmt::format("ThreadPool::destroy(): waiting for thread({0})[{1}], try={2}\n", count, taskaddrs, itry));
        }
    }

    THREAD_MUTEX_LOCK(threadStateList_mutex_);

    KBEngine::sleep(100);

    std::list<TPThread*>::iterator itr = allThreadList_.begin();
    for(; itr != allThreadList_.end(); itr++)
    {
        if((*itr))
        {
            delete (*itr);
            (*itr) = NULL;
        }
    }

    allThreadList_.clear();
    THREAD_MUTEX_UNLOCK(threadStateList_mutex_);

    THREAD_MUTEX_LOCK(finiTaskList_mutex_);

    if(finiTaskList_.size() > 0)
    {
        WARNING_MSG(fmt::format("ThreadPool::~ThreadPool(): Discarding {0} finished tasks.\n",
                                finiTaskList_.size()));

        std::list<TPTask*>::iterator finiiter  = finiTaskList_.begin();
        for(; finiiter != finiTaskList_.end(); finiiter++)
        {
            delete (*finiiter);
        }

        finiTaskList_.clear();
        finiTaskList_count_ = 0;
    }

    THREAD_MUTEX_UNLOCK(finiTaskList_mutex_);

    THREAD_MUTEX_LOCK(bufferedTaskList_mutex_);

    if(bufferedTaskList_.size() > 0)
    {
        WARNING_MSG(fmt::format("ThreadPool::~ThreadPool(): Discarding {0} buffered tasks.\n",
                                bufferedTaskList_.size()));

        while(bufferedTaskList_.size() > 0)
        {
            TPTask* tptask = bufferedTaskList_.front();
            bufferedTaskList_.pop();
            delete tptask;
        }
    }

    THREAD_MUTEX_UNLOCK(bufferedTaskList_mutex_);

    THREAD_MUTEX_DELETE(threadStateList_mutex_);
    THREAD_MUTEX_DELETE(bufferedTaskList_mutex_);
    THREAD_MUTEX_DELETE(finiTaskList_mutex_);

    DEBUG_MSG("ThreadPool::destroy(): successfully!\n");
}

Esempio n. 4

	virtual void uninitMutex(void)
	{
		THREAD_MUTEX_DELETE(mutex_);
	}

Esempio n. 5

File: threadpool.cpp Progetto: fengqk/kbengine

//-------------------------------------------------------------------------------------
void ThreadPool::destroy()
{
	isDestroyed_ = true;

	THREAD_MUTEX_LOCK(threadStateList_mutex_);

	DEBUG_MSG(boost::format("ThreadPool::destroy(): starting size %1%.\n") % 
		allThreadList_.size());
	
	THREAD_MUTEX_UNLOCK(threadStateList_mutex_);

	int itry = 0;
	while(true)
	{
		KBEngine::sleep(300);
		itry++;

		THREAD_MUTEX_LOCK(threadStateList_mutex_);
		int count = allThreadList_.size();
		std::list<TPThread*>::iterator itr = allThreadList_.begin();
		for(; itr != allThreadList_.end(); itr++)
		{
			if((*itr))
			{
				if((*itr)->getState() != TPThread::THREAD_STATE_END)
					(*itr)->sendCondSignal();
				else
					count--;
			}
		}

		THREAD_MUTEX_UNLOCK(threadStateList_mutex_);

		if(count <= 0)
		{
			break;
		}
		else
		{
			WARNING_MSG(boost::format("ThreadPool::destroy(): waiting for thread(%1%), try=%2%\n") % count % itry);
		}
	}

	THREAD_MUTEX_LOCK(threadStateList_mutex_);

	std::list<TPThread*>::iterator itr = allThreadList_.begin();
	for(; itr != allThreadList_.end(); itr++)
	{
		if((*itr))
		{
			delete (*itr);
			(*itr) = NULL;
		}
	}
	
	allThreadList_.clear();
	THREAD_MUTEX_UNLOCK(threadStateList_mutex_);

	THREAD_MUTEX_LOCK(finiTaskList_mutex_);
	
	if(finiTaskList_.size() > 0)
	{
		WARNING_MSG(boost::format("ThreadPool::~ThreadPool(): Discarding %1% finished tasks.\n") % 
			finiTaskList_.size());

		std::list<TPTask*>::iterator finiiter  = finiTaskList_.begin();
		for(; finiiter != finiTaskList_.end(); finiiter++)
		{
			delete (*finiiter);
		}
	
		finiTaskList_.clear();
	}

	THREAD_MUTEX_UNLOCK(finiTaskList_mutex_);

	THREAD_MUTEX_LOCK(bufferedTaskList_mutex_);

	if(bufferedTaskList_.size() > 0)
	{
		WARNING_MSG(boost::format("ThreadPool::~ThreadPool(): Discarding %1% buffered tasks.\n") % 
			bufferedTaskList_.size());

		while(bufferedTaskList_.size() > 0)
		{
			TPTask* tptask = bufferedTaskList_.front();
			bufferedTaskList_.pop();
			delete tptask;
		}
	}
	
	THREAD_MUTEX_UNLOCK(bufferedTaskList_mutex_);

	THREAD_MUTEX_DELETE(threadStateList_mutex_);
	THREAD_MUTEX_DELETE(bufferedTaskList_mutex_);
	THREAD_MUTEX_DELETE(finiTaskList_mutex_);

	DEBUG_MSG("ThreadPool::destroy(): successfully!\n");
}

Esempio n. 6

File: threadmutex.hpp Progetto: sdsgwangpeng/kbengine

 virtual ~ThreadMutex(void)
 {
     THREAD_MUTEX_DELETE(mutex_);
 }