Простая синхронизация потоков

Критические секции будут работать (они легче, чем мьютексы). /windows/desktop/ms686908(v=vs.85).aspx" rel="nofollow noreferrer" title="MSDN">MSDN.

void func()
{
    // cs previously initialized via InitializeCriticalSection
    EnterCriticalSection(&cs);
    operation1();
    operation2();
    LeaveCriticalSection(&cs);
    operation3();}
}

РЕДАКТИРОВАТЬ: Критические секции быстрее, чем мьютексы, поскольку критические секции в основном являются примитивами пользовательского режима - в случае неконкурентного захвата (обычно распространенный случай) в ядро ​​​​не выполняется системный вызов, а получение занимает порядка десятков циклов. Переключатель ядра дороже (порядка сотен циклов). Единственные критические по времени секции вызывают ядро ​​​​для блокировки, что включает ожидание примитива ядра (либо мьютекс, либо событие). Получение мьютекса всегда связано с обращением к ядру и, таким образом, на несколько порядков медленнее. Однако критические секции можно использовать только для синхронизации ресурсов в одном процессе. Для синхронизации между несколькими процессами необходим мьютекс.

Исправление решения Майкла выше.

Решение Michael идеально подходит для приложений C. Но при использовании в C++ этот стиль не рекомендуется из-за возможности исключений. Если в операции1 или операции2 произойдет исключение, критическая секция не будет правильно оставлена, и все остальные потоки будут заблокированы в ожидании.

// Perfect solutiuon for C applications
void func()
{
    // cs previously initialized via InitializeCriticalSection
    EnterCriticalSection(&cs);
    operation1();
    operation2();
    LeaveCriticalSection(&cs);
    operation3();}
}

// A better solution for C++
class Locker
{
    public:
    Locker(CSType& cs): m_cs(cs)
    {
        EnterCriticalSection(&m_cs);
    }
    ~Locker()
    {
        LeaveCriticalSection(&m_cs);
    }
    private:
        CSType&  m_cs;
}
void func()
{
    // cs previously initialized via InitializeCriticalSection
    {
        Locker  lock(cs);
        operation1();
        operation2();
    }
    operation3();
}

Лучшим методом было бы использовать критическую секцию, использовать EnterCriticalSection и LeaveCriticalSection. Единственная трудность заключается в том, что вам нужно сначала инициализировать критическую секцию с помощью InitializeCriticalSection. Если этот код находится внутри класса, поместите инициализацию в конструктор и структуру данных CRITICAL_SECTION в качестве члена класса. Если код не является частью класса, вам, вероятно, нужно использовать глобальный или что-то подобное, чтобы гарантировать, что он будет инициализирован один раз.

1. с помощью МФЦ:

   1. Определите объект синхронизации. (Мутекст или критический раздел)

      1.1 Если в функцию func() входит несколько потоков, принадлежащих разным процессам, используйте CMutex.

      1.2. Если несколько потоков одного и того же процесса входят в func(), используйте CCriticalSection.

   2. CSingleLock можно использовать для упрощения использования объектов синхронизации.

Допустим, мы определили критическую секцию

 CCriticalSection m_CriticalSection;
    void func()
    {
         // locking/mutex statement goes here
         CSingleLock aLock(&m_CriticalSection, **TRUE**); 
       // TRUE indicates that Lock aquired during aLock creation.
       // if FALSE used then use aLock.Lock() for locking.

         operation1();
         operation2();
          // corresponding unlock goes here
          aLock.Unlock();
         operation3();
    }

РЕДАКТИРОВАТЬ: см. статью VC++ из MSDN: Многопоточность с классами C++ и MFC и Многопоточность: как использовать классы синхронизации< /а>

Вы можете попробовать это:

void func()
{
    // See answer by Sasha on how to create the mutex
    WaitForSingleObject (mutex, INFINITE);
    operation1();
    operation2();
    ReleaseMutex(mutex);
    operation3();
}