threads_1/h/threads.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.

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

*/
/*
  Threads 1
*/

#ifndef _THREADS_1__THREADS_HPP_
#define _THREADS_1__THREADS_HPP_

#include <cpp_util_2/h/nocopy.hpp>

#include <threads_1/h/declspec.hpp>

namespace threads_1
{

class _os_mutex_sem_t;
class _os_cond_var_t;
class _os_thread_t;
class _os_thread_id_t;

//
// mutex_sem_t
//

class THREADS_1__TYPE mutex_sem_t :
  private cpp_util_2::nocopy_t
{
  // Для реализации condition variable.
  friend class  _os_cond_var_t;
  friend class  cond_var_t;
  protected :
    _os_mutex_sem_t * m_sem;

  public :
    mutex_sem_t();
    ~mutex_sem_t();

    void
    lock() const;

    void
    release() const;


    class THREADS_1__TYPE lock_t :
      private cpp_util_2::nocopy_t
    {
      // Для реализации condition variable.
      friend class  _os_cond_var_t;
      private :
        const mutex_sem_t & m_sem;
      public :
        inline
        lock_t( const mutex_sem_t & sem )
          :
            m_sem( sem )
        {
          m_sem.lock();
        }
        inline
        ~lock_t()
        {
          m_sem.release();
        }
    };
};

//
// cond_var_t
//

class THREADS_1__TYPE cond_var_t :
  public cpp_util_2::nocopy_t
{
  protected :

    mutex_sem_t * m_sem;
    _os_cond_var_t *  m_cv;

    bool  m_is_own_mutex;

  public :

    cond_var_t();

    cond_var_t(
      mutex_sem_t * (*mutex_creator)() );
    cond_var_t(
      mutex_sem_t & sem );
    ~cond_var_t();


    void
    wait() const;


    void
    wait( const mutex_sem_t & ) const;


    operator const mutex_sem_t &() const;


    void
    lock() const;


    void
    release() const;


    void
    notify_one();


    void
    notify_all();


    static mutex_sem_t *
    own_mutex();
};

//
// mrd_sem_t
//


class THREADS_1__TYPE mrd_sem_t :
  public cpp_util_2::nocopy_t
{
  public :
    mrd_sem_t();
    ~mrd_sem_t();

    void
    rd_lock();

    void
    wr_lock();

    void
    release();


    class THREADS_1__TYPE rd_lock_t :
      private cpp_util_2::nocopy_t
    {
      private :
        mrd_sem_t & m_sem;
      public :
        inline
        rd_lock_t( mrd_sem_t & sem )
          :
            m_sem( sem )
        {
          m_sem.rd_lock();
        }
        inline
        ~rd_lock_t()
        {
          m_sem.release();
        }
    };


    class THREADS_1__TYPE wr_lock_t :
      private cpp_util_2::nocopy_t
    {
      private :
        mrd_sem_t & m_sem;
      public :
        inline
        wr_lock_t( mrd_sem_t & sem )
          :
            m_sem( sem )
        {
          m_sem.wr_lock();
        }
        inline
        ~wr_lock_t()
        {
          m_sem.release();
        }
    };

  private :

    mutex_sem_t m_lock;
    cond_var_t  m_unlocked_event;


    unsigned long m_lock_count;

    bool  m_is_lock_enabled;
};

//
// thread_t
//

class THREADS_1__TYPE thread_t :
  private cpp_util_2::nocopy_t
{
  friend class  _os_thread_t;
  protected :
    _os_thread_t *  m_t;

  public :
    thread_t();
    virtual ~thread_t();


    void
    start();

    void
    wait();

  protected :

    void
    sleep( unsigned long msec );

    virtual void
    body( void ) = 0;
};


THREADS_1__FUNC(void)
sleep_thread( unsigned long msec );

//
// osthread_id_t
//

class THREADS_1__TYPE osthread_id_t
{
  public :

    osthread_id_t();
    osthread_id_t(
      const osthread_id_t & o );
    ~osthread_id_t();

    osthread_id_t &
    operator=(
      const osthread_id_t & o );

    bool
    operator==( const osthread_id_t & o ) const;

    bool
    operator!=( const osthread_id_t & o ) const;

    bool
    operator<( const osthread_id_t & o ) const;

  private :
    _os_thread_id_t * m_id;
};

THREADS_1__FUNC(osthread_id_t)
query_current_thread_id();

typedef void (*pfn_thread_proc_t)( void * p_params );

THREADS_1__FUNC(void)
begin_thread( pfn_thread_proc_t proc,
  void * p_params );

} /* namespace threads_1 */

#endif

---