threads_1/win32/h/cond_var.hpp

/*

threads_1: Multithreading support library
Yauheni A. Akhotnikau (C) 2002-2003
eao197@yahoo.com
-------------------------------------------------

Permission is granted to anyone to use this software for any purpose on any
computer system, and to redistribute it freely, subject to the following
restrictions:

1. This software is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

2. The origin of this software must not be misrepresented, either by
   explicit claim or by omission.

3. Altered versions must be plainly marked as such, and must not be
   misrepresented as being the original software.

-------------------------------------------------

*/
#if !defined( _THREADS_1__WIN32__COND_VAR_HPP_ )
#define _THREADS_1__WIN32__COND_VAR_HPP_

#define WIN32_LEAN_AND_MEAN
#include <windows.h>

#include <cpp_util_2/h/nocopy.hpp>

#include <threads_1/h/threads.hpp>

// Для эффективности используются критические секции.
#include <threads_1/win32/h/mutex_sem.critsect.hpp>

namespace threads_1
{

class _os_cond_var_t :
  public cpp_util_2::nocopy_t
{
  private :

    _os_mutex_sem_t m_self_lock;

    HANDLE  m_notify_event;

    HANDLE  m_notify_processed;

    unsigned long m_awaiting;

    unsigned long m_to_wake;

  public :
    inline
    _os_cond_var_t()
    :
      m_awaiting( 0 )
    , m_to_wake( 0 )
    {
      m_notify_event = CreateEvent( 0, TRUE, FALSE, 0 );
      m_notify_processed = CreateEvent( 0, TRUE, FALSE, 0 );
    }
    inline
    ~_os_cond_var_t()
    {
      CloseHandle( m_notify_event );
      CloseHandle( m_notify_processed );
    }

    inline void
    wait( _os_mutex_sem_t & sem )
    {
      // Можно безопасно увеличить счетчик ожидающих
      // события нитей, т.к. sem захвачен нами.
      m_self_lock.lock();
      ++m_awaiting;
      m_self_lock.release();

      bool notify_processed = false;
      bool is_waked_up = false;

      // Начинаем цикл ожидания событий.
      sem.release();

      // Внимание! Всякие фокусы возможны между
      // освобождением sem и возникновением события.
      do
      {
        WaitForSingleObject( m_notify_event, INFINITE );

        // Событие произошло. Теперь, если это событие
        // предназначалось только для одной нити начинается
        // конкуренция за событие.
        m_self_lock.lock();

        if( m_to_wake )
        {
          // Нить попала в число тех, кому разрешено
          // проснуться.
          is_waked_up = true;
          --m_awaiting;

          if( !( --m_to_wake ) )
          {
            // Вся нотификация завершена.
            notify_processed = true;
            ResetEvent( m_notify_event );
          }
        }

        m_self_lock.release();

      } while( !is_waked_up );

      // Теперь нить, которая породила нотификацию
      // должна узнать, что ее нотификация обработана.
      if( notify_processed )
        SetEvent( m_notify_processed );

      sem.lock();
    }

    inline void
    notify_one()
    {
      m_self_lock.lock();

      // Пока можно безопасно манипулировать m_awaiting и m_to_wake,
      // т.к. наша нить владеет замком.
      if( m_awaiting )
      {
        // Проснуться может только одна нить.
        m_to_wake = 1;

        // Наш замок будет освобожден в do_notify().
        do_notify();
      }
      else
        m_self_lock.release();
    }

    inline void
    notify_all()
    {
      m_self_lock.lock();

      // Пока можно безопасно манипулировать m_awaiting и m_to_wake,
      // т.к. наша нить владеет замком.
      if( m_awaiting )
      {
        // Проснуться должны все нити.
        m_to_wake = m_awaiting;

        // Наш замок будет освобожден в do_notify().
        do_notify();
      }
      else
        m_self_lock.release();
    }

  private :
    inline void
    do_notify()
    {
      ResetEvent( m_notify_processed );
      SetEvent( m_notify_event );

      // Замок был захвачен в одном из методов notify_*.
      m_self_lock.release();

      WaitForSingleObject( m_notify_processed, INFINITE );
    }
};

} /* namespace threads_1 */

#endif

---