SynchroSpace.cpp

См. документацию.

/*
 * CntmLib - Подсчет ссылок, потоки, синхронизация, асинхронные процедуры, события
 * Copyright (c) 2005, Овсеевич Роман, CntmLib@mail.ru
 * _______________________________________________________________________________
 * Разрешено свободное использование, копирование, распространение, изменение
 * (изменение сведений об авторских правах запрещено). Запрещена продажа и 
 * включение всей библиотеки или ее частей в другие библиотеки. В сведениях об
 * авторских правах на программу (или сведениях о программе, об авторах, 
 * использованных средствах разработки и т.д.) должна быть указана информация
 * о библиотеке CntmLib, ее авторе и, возможно, сайте или email'е.
 * Библиотека поставляется "как есть", без каких-либо гарантий со стороны автора.
 */ 

#include <Cntm/Exceptions/NullArgException.h>
#include <Cntm/Synchro/SynchroSpace.h>

// TaskQueue //////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Cntm::SpecUtils::FastMutex Cntm::SynchroSpace::TaskQueue::mutex;

bool Cntm::SynchroSpace::TaskQueue::Add(TaskBase* Task)
{
        if (!Task) throw NullArgException("Cntm::SynchroSpace::TaskQueue::Add", "Синхрозадача не указана");
        
        // Добавляем в конец очереди заданий.
        try
        {
                SpecUtils::FastMutex::Lock lock(mutex);
                Task->InsertBefore(TasksHead());
                bool res = needExec;
                needExec = false;
                return res;
        }
        catch (...)
        {
                delete Task;
                throw;
        }
}

void Cntm::SynchroSpace::TaskQueue::Exec() throw()
{
        // Цикл выполнения рекурсивных задач. Если таких задач нет (первый вход в метод Exec()), то
        // lastRecurseTask будет указывать на голову списка. Цикл продолжается, пока не будет повторно
        // выполнена задача, вызвавшая рекурсию последней.
        TaskBase* task = TasksHead();
        while (task != lastRecurseTask)
        {
                task = NextTask(task); // Получаем без крит. секции, т.к. до lastRecurseTask ничего не меняется.
                try { if (task->IsRecursive()) task->Exec(true); } catch (...) {}
        }

        // Переход к следующей после рекурсивной или к первой задаче.
        {
                SpecUtils::FastMutex::Lock lock(mutex);
                task = NextTask(task);
                if (task == TasksHead())
                {
                        needExec = true;
                        return;
                }
        }
        
        // Цикл прохода по заданиям.
        TaskBase* oldLastRecurseTask = lastRecurseTask;
        while (true)
        {
                lastRecurseTask = task;
                try { task->Exec(); } catch (...) {}
                
                {
                        SpecUtils::FastMutex::Lock lock(mutex);
                        task = NextTask(task);
                        lastRecurseTask->Remove();
                        if (task == TasksHead())
                        {
                                needExec = true;
                                break;
                        }
                }

                try { delete lastRecurseTask; } catch (...) {}
        }
        try { delete lastRecurseTask; } catch (...) {}
        lastRecurseTask = oldLastRecurseTask;
}


// SynchroSpace ///////////////////////////////////////////////////////////////////////////////////////////////////////////////

Cntm::SynchroSpace::IMainSynchroSpaceFactory* Cntm::SynchroSpace::mainFactory = NULL;

Cntm::SpecUtils::SysThreadIdentifier Cntm::SynchroSpace::mainThreadId;

Cntm::SpecUtils::SysThreadLocalInt Cntm::SynchroSpace::reentrantCounter;
                
Cntm::SpecUtils::SysThreadLocalInt Cntm::SynchroSpace::noReentrantCounter;

bool Cntm::SynchroSpace::IsReentrantMode() const
{
        return noReentrantCounter.Value() == 0;
}

void Cntm::SynchroSpace::Enter(bool ReentrantMode)
{
        DoEnter();
        UpdateCounters(ReentrantMode, +1);
}
        
bool Cntm::SynchroSpace::TryEnter(bool ReentrantMode)
{
        if (!DoTryEnter()) return false;
        UpdateCounters(ReentrantMode, +1);
        return true;
}
        
void Cntm::SynchroSpace::Leave(bool ReentrantMode)
{
        UpdateCounters(ReentrantMode, -1);
        DoLeave();
}

void Cntm::SynchroSpace::UpdateCounters(bool ReentrantMode, int Sign)
{
        if (ReentrantMode)
                reentrantCounter.SetValue(reentrantCounter.Value() + Sign);
        else
                noReentrantCounter.SetValue(noReentrantCounter.Value() + Sign);
}

---