Category

Development Platform
Home > SourceCode/Document > Linux-Unix program > View Code
mutex.C
Package: threads-2.0.tar.gz　[view]
Upload User: shtangtang
Upload Date: 2007-01-04
Package Size: 167k
Code Size: 4k
Category:

Linux-Unix program

Development Platform:

Unix_Linux

mutex.C：Code Content
  1. //
  2. // class mutex
  3. //
  4. // Mutes is a semaphore, that can be used by two threads to mutually
  5. // exclude the other.  To ensure uniqe access to memory.
  7. #include <thread_mutex.h>
  8. #include <thread_lists.h>
  9. #include "wait_queue.h"
  10. #include "shared.h"
  12. extern "C" {
  14. # include <errno.h>
  15. #       include <unistd.h>
  17. };
  19. char *mutex::m_project = 0;
  21. mutex::mutex(attributes::scope p_scope)
  22. {
  23.   init( p_scope );
  24. }
  26. mutex::mutex()
  27. {
  28.   init( attributes::process_private );
  29. }
  31. mutex::~mutex()
  32. {
  33.   if ( _m ) {
  34.     delete m_waiting;
  35.     if ( m_scope == attributes::process_private )
  36.       delete _m;
  37.     else 
  38.       shared_mem::share.dealloc( _m );
  39.     _m = 0;
  40.   }
  41. }
  43. void mutex::init(attributes::scope p_scope)
  44. {
  45.   m_id = -1;
  46.   if ( p_scope == attributes::process_private ) {
  47.     _m            = new storage;
  48.     _m->m_magic   = 0;
  49.   } else {
  50.    m_id           = shared_mem::share.create_proj( m_project );
  51.    _m             = (storage *)shared_mem::share.alloc( sizeof(storage),m_id );
  52.    assert( _m != (storage *)-1 );
  53.   }
  54.   if ( _m->m_magic != 0x212612 ) {
  55.     _m->m_kind    = fast;
  56.     _m->m_count   = 0;
  57.     _m->m_owner   = -1;
  58.     _m->m_magic   = 0x212612;
  59.   }
  60.   m_waiting       = new wait_queue( m_id );
  61.   m_scope         = p_scope;
  62. }
  64. attributes::scope mutex::scope()
  65. {
  66.   return m_scope;
  67. }
  69. void mutex::release()
  70. {
  71.   _m->m_owner = 0;
  72.   _m->m_count = 0;
  73. }
  75. int mutex::acquire()
  76. {
  77.   _m->m_owner = getpid();
  78.   _m->m_count++;
  79.   return 0;
  80. }
  82. //
  83. // kind
  84. //
  85. // set the mutex kind.
  86. int mutex::kind(mutex_kind _kind)
  87. {
  88.   if (_kind != mutex::recursive && _kind != mutex::fast)
  89.     return EINVAL;
  90.   _m->m_kind = _kind;
  91.   return 0;
  92. }
  94. //
  95. // kind
  96. //
  97. // get the mutex kind.
  98. int mutex::kind()
  99. {
  100.   return _m->m_kind;
  101. }
  103. //
  104. // trylock
  105. //
  106. // try and lock the mutex.
  107. //
  108. // return
  109. //   EBUSY  - the mutex is locked by another.
  110. //   EINVAL - the mutex is of an unknown kind.
  111. //   0      - successful.
  112. int mutex::trylock()
  113. {
  114.   int rval = EBUSY;
  116.   _m->m_spinlock.acquire();
  117.   switch(_m->m_kind) {
  118.   case mutex::fast:
  119.     if ( _m->m_count == 0 )
  120.       rval = acquire();
  121.     break;
  122.   case mutex::recursive:
  123.     if (_m->m_count == 0 || _m->m_owner == getpid())
  124.       rval = acquire();
  125.     break;
  126.   case mutex::errorcheck:
  127.     if ( _m->m_count == 0 )
  128.       rval = acquire();
  129.     else
  130.       if ( _m->m_owner == getpid() )
  131. rval = EDEADLK;
  132.     break;
  133.   default:
  134.     rval = EINVAL;
  135.     break;
  136.   }
  137.   _m->m_spinlock.release();
  139.   return rval;
  140. }
  142. //
  143. // lock
  144. //
  145. // Try and lock the mutex.  If unsuccessful, suspend the calling
  146. // process, until the mutex is available.
  147. int mutex::lock()
  148. {
  149.   int rval = EBUSY;
  151.   while(rval == EBUSY) {
  152.     if ((rval = trylock()) == EBUSY)
  153.       m_waiting->suspend_me();
  154.   }
  155.   return rval;
  156. }
  158. //
  159. // unlock
  160. //
  161. // unlock the mutex, and restart any threads, that are waiting
  162. // on it.
  163. int mutex::unlock()
  164. {
  165.   int rval = 0;
  167.   _m->m_spinlock.acquire();
  168.   switch(_m->m_kind) {
  169.   case mutex::fast:
  170.     if ( _m->m_owner == getpid() )
  171.       release();
  172.     else
  173.       rval = EBUSY;
  174.     break;
  175.   case mutex::recursive:
  176.     if ( _m->m_owner == getpid() ) {
  177.       if (--_m->m_count <= 1)
  178. release();
  179.     } else
  180.       rval = EBUSY;
  181.     break;
  182.   case mutex::errorcheck:
  183.     if ( _m->m_count == 0 || _m->m_owner != getpid() )
  184.       rval = EPERM;
  185.     else
  186.       release();
  187.     break;
  188.   default:
  189.     rval = EINVAL;
  190.   }
  191.   _m->m_spinlock.release();
  192.   if ( rval == 0 )
  193.     m_waiting->wake_up();
  194.   return rval;
  195. }
  197. //
  198. // project_part
  199. //
  200. // change the project part
  201. void
  202. mutex::project_part(const char *p_part)
  203. {
  204.   if ( m_project == 0 )
  205.     m_project = new char[80];
  206.   m_project[0] = 0;
  207.   if ( p_part )
  208.     strcpy( m_project,p_part );
  209. }