随笔-88  评论-224  文章-23  trackbacks-0
   互斥锁,用来保证任一时刻只有单个线程或进程拥有对共享资源的互斥访问权,在这里将posix thread中的互斥体、win32中的互斥体和临界区,统称为互斥锁,其特点如下:
   ● 范围线程锁进程锁,前者仅用于同一进程内多线程间,而后者用于进程间,显然,它也能用于同一进程内多线程间,但效率较低。posix的互斥体既可以是线程锁,也可以是进程锁,这由它的一个属性决定:pthread_process_shared或pthread_process_private。win32中的临界区是一种线程锁,而互斥体既可以是线程锁,也可以是进程锁,这由它的一个名称决定:createmutex中的第3个参数。
   ● 类型:posix中的互斥体,包括普通锁递归锁检测锁适应锁四种;而win32中的临界区在同一线程内可多次加锁和解锁,相当于递归锁,而互斥体则相当于普通锁。
   ● 操作:包括创建锁、加锁、解锁、检测锁和销毁锁5种操作,其中加锁操作又可分为永久等待超时等待2种。对于win32中的临界区,不存在超时等待的加锁。

接口
   所有锁操作,成功返回0,失败posix返回非0的错误码,win32返回-1,调用getlasterror可获取错误码。对于超时加锁,第2个参数超时不是时间差,而是绝对到期时间。对于win32中的互斥体,废弃返回1,超时返回2。
 1#ifdef _POSIX_THREAD
 2#include <pthread.h>
 3#include <sys/time.h>
 4
 5typedef pthread_mutex_t mutex_t;
 6typedef pthread_mutexattr_t mutexattr_t;
 7typedef void SECURITY_ATTRIBUTES;
 8
 9#elif defined(_WIN32_THREAD)
10#ifndef _WIN32_WINNT
11# define _WIN32_WINNT 0x0501
12#endif
13#include <winsock2.h>
14
15typedef struct  
16{
17    int type_;
18    union
19    {
20        HANDLE proc_lock_;
21        CRITICAL_SECTION thr_lock_;
22    }
;
23}
mutex_t;
24typedef void mutexattr_t;
25
26#else
27#error Currently only support win32 and posix thread models
28#endif
29
30#define MUTEX_THREAD_SHARED  1
31#define MUTEX_PROCESS_SHARED 2
32
33int mutex_init(mutex_t* m,int scope,int type,const char* name,
34               mutexattr_t* attr,SECURITY_ATTRIBUTES* sa);
35
36int mutex_lock(mutex_t* m);
37
38int mutex_timedlock(mutex_t* m,const struct timeval* val);
39
40int mutex_trylock(mutex_t* m);
41
42int mutex_unlock(mutex_t* m);
43
44int mutex_destroy(mutex_t* m);

实现 
  1int mutex_init(mutex_t* m,int scope,int type,const char* name,mutexattr_t* attr,SECURITY_ATTRIBUTES* sa)
  2{
  3#ifdef _POSIX_THREAD
  4    int ret, init = 0;
  5    pthread_mutexattr_t tmp;
  6    if(0==attr) attr = &tmp;
  7    if(attr==&tmp)
  8    {
  9        ret = pthread_mutexattr_init(attr);
 10        if (0==ret) init = 1;
 11    }

 12    if(0==ret && 0 != scope)
 13    {
 14#ifdef  _POSIX_THREAD_PROCESS_SHARED
 15        ret = pthread_mutexattr_setpshared(attr,lock_scope);
 16#endif
 17    }

 18    if(0==ret && 0 != type)
 19    {
 20#ifdef __USE_UNIX98
 21        ret = pthread_mutexattr_settype(attr,lock_type);
 22#endif
 23    }

 24    if (0==ret)
 25        ret = pthread_mutex_init(m,attr);
 26    if (1==init && attr==&tmp)
 27        pthread_mutexattr_destroy(attr);
 28    return ret;
 29#else
 30    m->type_ = scope;
 31    switch (m->type_)
 32    {
 33    case MUTEX_THREAD_SHARED:
 34        __try
 35        {
 36            InitializeCriticalSection(&m->thr_lock_);
 37        }

 38        __except(EXCEPTION_EXECUTE_HANDLER)
 39        {
 40            return -1;
 41        }

 42        return 0;
 43
 44    case MUTEX_PROCESS_SHARED:
 45        m->proc_lock_ = CreateMutexA(sa,FALSE,name);
 46        if (0==m->proc_lock_&&ERROR_ACCESS_DENIED==GetLastError())
 47            m->proc_lock_ = OpenMutexA(MUTEX_ALL_ACCESS,FALSE,name);
 48        if (0==m->proc_lock_)
 49            return -1;        
 50        return 0;
 51
 52    defaultreturn -1;
 53    }

 54#endif
 55}

 56
 57int mutex_lock(mutex_t* m)
 58{
 59#ifdef _POSIX_THREAD
 60    return pthread_mutex_lock(m);
 61#else
 62    switch(m->type_)
 63    {
 64    case MUTEX_THREAD_SHARED:
 65        EnterCriticalSection(&m->thr_lock_);
 66        return 0;
 67    
 68    case MUTEX_PROCESS_SHARED:
 69        switch (WaitForSingleObject (m->proc_lock_, INFINITE))
 70        {
 71        case WAIT_OBJECT_0:  return 0;
 72        case WAIT_ABANDONED: return 1;
 73        defaultreturn -1;
 74        }

 75        break;
 76
 77    defaultreturn -1
 78    }

 79#endif
 80}

 81
 82int mutex_timedlock(mutex_t* m,const struct timeval* val)
 83{
 84    //val should be an absolute time.
 85#ifdef _POSIX_THREAD
 86    struct timespec ts = {.tv_sec = val->tv_sec,.tv_nsec=val->tv_usec*1000};
 87    return pthread_mutex_timedlock(m,&ts);
 88#else
 89    switch(m->type_)
 90    {
 91    // not support CriticalSection,so simply return -1.
 92    case MUTEX_THREAD_SHARED:
 93        return -1
 94
 95    case MUTEX_PROCESS_SHARED:
 96        {
 97            FILETIME ft;
 98            struct timeval cur,diff;
 99        
100            GetSystemTimeAsFileTime(&ft);
101            cur = FileTime2TimeVal(&ft);
102            diff = timeval_sub(val,&cur);
103
104            switch (WaitForSingleObject (m->proc_lock_, timeval_millsec(&diff)))
105            {
106            case WAIT_OBJECT_0:  return 0;
107            case WAIT_ABANDONED: return 1;
108            case WAIT_TIMEOUT:      return 2;
109            defaultreturn -1;
110            }

111        }

112        break;
113
114    defaultreturn -1;
115    }

116#endif
117}

118
119int mutex_trylock(mutex_t* m)
120{
121#ifdef _POSIX_THREAD
122    return pthread_mutex_trylock(m);
123#else
124    switch(m->type_)
125    {
126    case MUTEX_THREAD_SHARED:
127        if (!TryEnterCriticalSection(&m->thr_lock_))
128            return -1;
129        return 0;
130        
131    case MUTEX_PROCESS_SHARED:
132        switch (WaitForSingleObject (m->proc_lock_, 0))
133        {
134        case WAIT_OBJECT_0:  return 0;
135        case WAIT_ABANDONED: return 1;
136        case WAIT_TIMEOUT:   return 2;
137        defaultreturn -1;
138        }

139        break;
140
141    defaultreturn -1;
142    }

143#endif
144}

145
146int mutex_unlock(mutex_t* m)
147{
148#ifdef _POSIX_THREAD
149    return pthread_mutex_unlock(m);
150#else
151    switch(m->type_)
152    {
153    case MUTEX_THREAD_SHARED:
154        LeaveCriticalSection(&m->thr_lock_);
155        return 0;
156
157    case MUTEX_PROCESS_SHARED:
158        if (!ReleaseMutex(m->proc_lock_))
159            return -1;
160        return 0;
161
162    defaultreturn -1;
163    }

164#endif
165}

166
167int mutex_destroy(mutex_t* m)
168{
169#ifdef _POSIX_THREAD
170    return pthread_mutex_destroy(m);
171#else
172    switch(m->type_)
173    {
174    case MUTEX_THREAD_SHARED:
175        DeleteCriticalSection(&m->thr_lock_);
176        return 0;
177
178    case MUTEX_PROCESS_SHARED:
179        if (!CloseHandle(m->proc_lock_))
180            return -1;
181        return 0;
182
183    defaultreturn -1;
184    }

185#endif
186}

posted on 2012-06-23 00:08 春秋十二月 阅读(2414) 评论(2)  编辑 收藏 引用 所属分类: C/C++

评论:
# re: 一种简单的跨平台互斥锁 2012-06-24 12:19 | 易宝@byhh
这样搞可以用来学习,用的时候有点没必要。

之前有过一个关于宏的探讨。 若有十个函数都要用到跨平台的宏。是用

#ifdef ABCD

fun1

fun2 .....
fun10

#else


#endif 好一些。

还是用

fun1
{
#ifdef

#else

#endif
}

fun2...

fun10

好一些。

从你的代码上来看。 用第一种反而好一些。定义了某个平台后,另一个平台的代码直接不用看了。  回复  更多评论
  
# re: 一种简单的跨平台互斥锁 2012-07-13 16:04 | erran
@易宝@byhh

严重同意,

不然视同乱码。。。。。。。。。。。。
  回复  更多评论
  

只有注册用户登录后才能发表评论。
【推荐】超50万行VC++源码: 大型组态工控、电力仿真CAD与GIS源码库
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理