Chinaunix首页 | 论坛 | 博客

yyxl的ChinaUnix博客yyyw.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

yyxl

  • 博客访问： 3547119
  • 博文数量： 1805
  • 博客积分： 135
  • 博客等级： 入伍新兵
  • 技术积分： 3345
  • 用 户 组： 普通用户
  • 注册时间： 2010-03-19 20:01
文章分类

全部博文（1805）

文章存档

2017年（19）

2016年（80）

2015年（341）

2014年（438）

2013年（349）

2012年（332）

2011年（248）

我的朋友
最近访客
推荐博文
线程同步机制

分类：

2011-10-21 12:56:39

原文地址：线程同步机制 作者：zhangchuhu

线程同步有三种常用的机制: 互斥量(mutex), 读写锁(rwlock)和条件变量(cond).
互斥量
    互斥量从本质上说就是一把锁, 提供对共享资源的保护访问.
1. 初始化:
    在Linux下, 线程的互斥量数据类型是pthread_mutex_t. 在使用前, 要对它进行初始化:
对于静态分配的互斥量, 可以把它设置为PTHREAD_MUTEX_INITIALIZER, 或者调用pthread_mutex_init.
对于动态分配的互斥量, 在申请内存(malloc)之后, 通过pthread_mutex_init进行初始化, 并且在释放内存(free)前需要调用pthread_mutex_destroy.
原型:
int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restric attr);
int pthread_mutex_destroy(pthread_mutex_t *mutex);
头文件:
返回值: 成功则返回0, 出错则返回错误编号.
说明: 如果使用默认的属性初始化互斥量, 只需把attr设为NULL. 其他值在以后讲解.
2. 互斥操作:
    对共享资源的访问, 要对互斥量进行加锁, 如果互斥量已经上了锁, 调用线程会阻塞, 直到互斥量被解锁. 在完成了对共享资源的访问后, 要对互斥量进行解锁.
首先说一下加锁函数:
头文件:
原型:
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
返回值: 成功则返回0, 出错则返回错误编号.
说 明: 具体说一下trylock函数, 这个函数是非阻塞调用模式, 也就是说, 如果互斥量没被锁住, trylock函数将把互斥量加锁, 并获得对共享资源的访问权限; 如果互斥量被锁住了, trylock函数将不会阻塞等待而直接返回EBUSY, 表示共享资源处于忙状态.
再说一下解所函数:
头文件:
原型: int pthread_mutex_unlock(pthread_mutex_t *mutex);
返回值: 成功则返回0, 出错则返回错误编号.
3. 死锁:
    死锁主要发生在有多个依赖锁存在时, 会在一个线程试图以与另一个线程相反顺序锁住互斥量时发生. 如何避免死锁是使用互斥量应该格外注意的东西.
    总体来讲, 有几个不成文的基本原则:
对共享资源操作前一定要获得锁.
完成操作以后一定要释放锁.
尽量短时间地占用锁.
如果有多锁, 如获得顺序是ABC连环扣, 释放顺序也应该是ABC.
线程错误返回时应该释放它所获得的锁.
  1. ifndef __TCMUTEX_H__
  2. #define __TCMUTEX_H__

  4. #if !defined(AFX_MUTEX_H__5B26703E_B4A3_4247_B78C_0A5FD39BD73A__INCLUDED_)
  5. #define AFX_MUTEX_H__5B26703E_B4A3_4247_B78C_0A5FD39BD73A__INCLUDED_

  7. #include

  9. class TCMutex
  10. {
  11. public:
  12.     TCMutex();
  13.     virtual ~TCMutex();
  14.     /**    @brief    锁 */
  15.     void Lock();
  16.     /**    @brief    解锁 */
  17.     void UnLock();

  19.     bool IsLocked()
  20.     {
  21.         return m_lock;
  22.     }

  24. #ifndef __WIN32__
  25.     pthread_mutex_t* GetMutex()
  26.     {
  27.         return & m_mutex;
  28.     }    
  29. #else
  30.     CRITICAL_SECTION * GetMutex()
  31.     {
  32.         return & m_singlelock;
  33.     }
  34. #endif

  36. private:

  38. #ifndef __WIN32__
  39.     pthread_mutex_t m_mutex;
  40.     pthread_mutexattr_t m_attr;
  41. #else
  42.     CRITICAL_SECTION m_singlelock;
  43. #endif

  45.     bool m_lock;
  46. };
  47. #endif
  1. #ifndef FALSE
  2. #define FALSE 0
  3. #endif

  5. #ifndef TRUE
  6. #define TRUE 1
  7. #endif

  9. /** @file    TCMutex.cpp
  10. *    @brief    互斥类源码文件
  11. *    @version 1.0
  12. *    @date 2008-12-21*/

  14. TCMutex::TCMutex()
  15. {
  16. #ifndef __WIN32__
  17.     pthread_mutexattr_init( & m_attr );
  18. #ifdef __LINUX__
  19.     pthread_mutexattr_settype(& m_attr,PTHREAD_MUTEX_RECURSIVE_NP);
  20. #else
  21.     pthread_mutexattr_settype(& m_attr,PTHREAD_MUTEX_RECURSIVE);    
  22. #endif    
  23.     pthread_mutex_init( & m_mutex, & m_attr);
  24. #else
  25.     InitializeCriticalSection( &m_singlelock );
  26. #endif    
  27.     m_lock = false;
  28. }

  30. TCMutex::~TCMutex()
  31. {
  32. #ifndef __WIN32__
  33.     pthread_mutex_destroy( &m_mutex );
  34. #else
  35.     DeleteCriticalSection( &m_singlelock );
  36. #endif
  37. }


  40. void TCMutex::Lock()
  41. {
  42. #ifndef __WIN32__
  43.     pthread_mutex_lock( &m_mutex );
  44.     //if ( pthread_mutex_lock( &m_mutex ) < 0 )
  45.     //{
  46.     //    throw TCException("Lock() exception!");
  47.     //}
  48. #else
  49.     EnterCriticalSection( &m_singlelock );
  50. #endif
  51.     m_lock = true;
  52. }

  54. void TCMutex::UnLock()
  55. {
  56. #ifndef __WIN32__
  57.     pthread_mutex_unlock( &m_mutex );
  58.     //if ( pthread_mutex_unlock( &m_mutex ) < 0 )
  59.     //{
  60.     //    throw TCException("UnLock() exception!");
  61.     //}
  62. #else
  63.     LeaveCriticalSection( &m_singlelock );
  64. #endif
  65.     m_lock = false;
  66. }

读写锁
    在线程同步系列的第一篇文章里已经说过, 读写锁是因为有3种状态, 所以可以有更高的并行性.
1. 特性:
    一次只有一个线程可以占有写模式的读写锁, 但是可以有多个线程同时占有读模式的读写锁. 正是因为这个特性,
当读写锁是写加锁状态时, 在这个锁被解锁之前, 所有试图对这个锁加锁的线程都会被阻塞.
当读写锁在读加锁状态时, 所有试图以读模式对它进行加锁的线程都可以得到访问权, 但是如果线程希望以写模式对此锁进行加锁, 它必须阻塞直到所有的线程释放锁.
通常, 当读写锁处于读模式锁住状态时, 如果有另外线程试图以写模式加锁, 读写锁通常会阻塞随后的读模式锁请求, 这样可以避免读模式锁长期占用, 而等待的写模式锁请求长期阻塞.
2. 适用性:
    读写锁适合于对数据结构的读次数比写次数多得多的情况. 因为, 读模式锁定时可以共享, 以写模式锁住时意味着独占, 所以读写锁又叫共享-独占锁.
3. 初始化和销毁:
#include
int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr);
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
成功则返回0, 出错则返回错误编号.
同互斥量以上, 在释放读写锁占用的内存之前, 需要先通过pthread_rwlock_destroy对读写锁进行清理工作, 释放由init分配的资源.
4. 读和写:
#include
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
成功则返回0, 出错则返回错误编号.
这3个函数分别实现获取读锁, 获取写锁和释放锁的操作. 获取锁的两个函数是阻塞操作, 同样, 非阻塞的函数为:
#include
int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
成功则返回0, 出错则返回错误编号.
非阻塞的获取锁操作, 如果可以获取则返回0, 否则返回错误的EBUSY.
    1. ifndef __TCRWLOCK_H__
    2. #define __TCRWLOCK_H__

    4. #if !defined(AFX_MUTEX_H__5B26703E_B4A3_4247_B78C_0A5FD39BD73A__INCLUDED_)
    5. #define AFX_MUTEX_H__5B26703E_B4A3_4247_B78C_0A5FD39BD73A__INCLUDED_

    7. #include

    9. #ifdef __WIN32__

    11. typedef struct _RWLock
    12. {
    13.     HANDLE    hMutex;
    14.     HANDLE    hDataLock;
    15.     int        nReaderCount;
    16. } RWLock;

    18. #endif

    20. class TCRWLock
    21. {
    22. public:
    23.     TCRWLock();
    24.     ~TCRWLock();

    26.     bool ReadLock(void); //请求读操作锁,请求不成功则阻塞
    27.     bool ReleaseReadLock(void); //释放读操作锁

    29.     bool WriteLock(void); //请求写操作锁,请求不成功则阻塞
    30.     bool ReleaseWriteLock(void); //释放写操作锁

    32. private:
    33. #ifdef __WIN32__
    34.     bool MyWaitForSingleObject(HANDLE hObject);
    35. #else
    36.     bool MyWaitForSingleObject(void * hObject);
    37. #endif
    38.     bool InitRWLock();
    39.     bool DestroyRWLock();
    40. private:

    42. #ifdef __WIN32__
    43.     RWLock    m_RWLock; //读写锁
    44. #else
    45.     pthread_rwlock_t m_RWLock;
    46. #endif

    48. };

    50. typedef class TCMutex CMyMutex;
    51. typedef class TCRWLock CRWLock;


    54. #endif // !defined(AFX_MUTEX_H__5B26703E_B4A3_4247_B78C_0A5FD39BD73A__INCLUDED_)
    1. //读写锁

    3. //完成读写锁初始化
    4. TCRWLock::TCRWLock()
    5. {
    6.     if( !InitRWLock() )
    7.     {
    8.         throw TCException("Init RwLock Error!");
    9.     }
    10. }

    12. TCRWLock::~TCRWLock()
    13. {
    14.     DestroyRWLock();
    15. }

    17. #ifdef __WIN32__
    18. bool TCRWLock::MyWaitForSingleObject(HANDLE hObject)
    19. #else
    20. bool TCRWLock::MyWaitForSingleObject(void * hObject)
    21. #endif
    22. {
    23. #ifdef __WIN32__
    24.     DWORD result;
    25.     result = WaitForSingleObject(hObject, INFINITE);

    27.     return (result == WAIT_OBJECT_0);
    28. #else
    29.     return true;
    30. #endif
    31. }

    33. bool TCRWLock::InitRWLock()
    34. {
    35. #ifdef __WIN32__
    36.     m_RWLock.nReaderCount = 0;
    37.     m_RWLock.hDataLock = CreateSemaphore(NULL, 1, 1, NULL);

    39.     if (m_RWLock.hDataLock == NULL)
    40.     {
    41.         return false;
    42.     }

    44.     m_RWLock.hMutex = CreateMutex(NULL, FALSE, NULL);

    46.     if (m_RWLock.hMutex == NULL)
    47.     {
    48.         CloseHandle(m_RWLock.hDataLock);
    49.         return false;
    50.     }

    52.     return true;
    53. #else
    54.     
    55.     if( pthread_rwlock_init(&m_RWLock, NULL) != 0 )
    56.     {
    57.         throw TCException("TCRWLock::InitRWLock() exception!");
    58.     }

    60.     return true;
    61. #endif
    62. }

    64. bool TCRWLock::DestroyRWLock()
    65. {
    66. #ifdef __WIN32__
    67.     DWORD result = WaitForSingleObject(m_RWLock.hDataLock, INFINITE);

    69.     if (result != WAIT_OBJECT_0)
    70.     {
    71.         return false;
    72.     }

    74.     CloseHandle(m_RWLock.hMutex);
    75.     CloseHandle(m_RWLock.hDataLock);

    77.     return true;
    78. #else
    79.     pthread_rwlock_destroy(&m_RWLock);

    81.     return true;
    82. #endif
    83. }

    85. bool TCRWLock::ReadLock()
    86. {
    87. #ifdef __WIN32__
    88.     bool result = TRUE;

    90.     if (MyWaitForSingleObject(m_RWLock.hMutex) == FALSE)
    91.     {
    92.         return FALSE;
    93.     }

    95.     ++ m_RWLock.nReaderCount;

    97.     if(m_RWLock.nReaderCount == 1)
    98.     {
    99.         result = MyWaitForSingleObject(m_RWLock.hDataLock);
    100.     }

    102.     ReleaseMutex(m_RWLock.hMutex);

    104.     return result;
    105. #else
    106.     if (pthread_rwlock_rdlock(&m_RWLock) != 0)
    107.     {
    108.         throw TCException("RLock() exception!");
    109.     }

    111.     return true;
    112. #endif
    113. }

    115. bool TCRWLock::ReleaseReadLock()
    116. {
    117. #ifdef __WIN32__
    118.     LONG lPrevCount;
    119.     int result = TRUE;

    121.     if (MyWaitForSingleObject(m_RWLock.hMutex) == FALSE)
    122.     {
    123.         return false;
    124.     }

    126.     --m_RWLock.nReaderCount;

    128.     if (m_RWLock.nReaderCount == 0)
    129.     {
    130.         result = ReleaseSemaphore(m_RWLock.hDataLock, 1, &lPrevCount);
    131.     }

    133.     ReleaseMutex(m_RWLock.hMutex);

    135.     return result;
    136. #else
    137.     if (pthread_rwlock_unlock(&m_RWLock) != 0)
    138.     {
    139.         throw TCException("TCRWLock::ReleaseReadLock() exception!");
    140.     }

    142.     return true;
    143. #endif
    144. }

    146. bool TCRWLock::WriteLock()
    147. {
    148. #ifdef __WIN32__
    149.     return MyWaitForSingleObject(m_RWLock.hDataLock);
    150. #else
    151.     if (pthread_rwlock_wrlock(&m_RWLock) != 0)
    152.     {
    153.         throw TCException("TCRWLock::WLock() exception!");
    154.     }
    155.     return true;
    156. #endif
    157. }


    160. bool TCRWLock::ReleaseWriteLock()
    161. {
    162. #ifdef __WIN32__
    163.     int result = TRUE;
    164.     LONG lPrevCount;

    166.     result = ReleaseSemaphore(m_RWLock.hDataLock, 1, &lPrevCount);

    168.     if (lPrevCount != 0)
    169.     {
    170.         return false;
    171.     }

    173.     return result;
    174. #else
    175.     if (pthread_rwlock_unlock(&m_RWLock) != 0)
    176.     {
    177.         throw TCException("TCRWLock::ReleaseWriteLock() exception!");
    178.     }

    180.     return true;
    181. #endif
    182. }

    条件变量
         条件变量分为两部分: 条件和变量. 条件本身是由互斥量保护的. 线程在改变条件状态前先要锁住互斥量.
    1. 初始化:
        条件变量采用的数据类型是pthread_cond_t, 在使用之前必须要进行初始化, 这包括两种方式:
    静态: 可以把常量PTHREAD_COND_INITIALIZER给静态分配的条件变量.
    动态: pthread_cond_init函数, 是释放动态条件变量的内存空间之前, 要用pthread_cond_destroy对其进行清理.
    #include
    int pthread_cond_init(pthread_cond_t *restrict cond, pthread_condattr_t *restrict attr);
    int pthread_cond_destroy(pthread_cond_t *cond);
    成功则返回0, 出错则返回错误编号.
        当pthread_cond_init的attr参数为NULL时, 会创建一个默认属性的条件变量; 非默认情况以后讨论.
    2. 等待条件:
    #include
    int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restric mutex);
    int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, const struct timespec *restrict timeout);
    成功则返回0, 出错则返回错误编号.
        这两个函数分别是阻塞等待和超时等待.
        等待条件函数等待条件变为真, 传递给pthread_cond_wait的互斥量对条件进行保护, 调用者把锁住的互斥量传递给函数. 函数把调用线程放到等待条件的线程列表上, 然后对互斥量解锁, 这两个操作是原子的. 这样便关闭了条件检查和线程进入休眠状态等待条件改变这两个操作之间的时间通道, 这样线程就不会错过条件的任何变化.
        当pthread_cond_wait返回时, 互斥量再次被锁住.
    3. 通知条件:
    #include
    int pthread_cond_signal(pthread_cond_t *cond);
    int pthread_cond_broadcast(pthread_cond_t *cond);
    成功则返回0, 出错则返回错误编号.
        这两个函数用于通知线程条件已经满足. 调用这两个函数, 也称向线程或条件发送信号. 必须注意, 一定要在改变条件状态以后再给线程发送信号.

     
    1. ///
    2. /// @file Lock.h
    3. /// @brief
    4. /// @author guozhiming
    5. /// @date 2007-04-11
    6. ///

    8. #ifndef __LOCK__
    9. #define __LOCK__
    10. #include "def.h"

    12. /// @brief 锁的基本操作 1：读操作的时候读锁可以并发 2：写操作的时候，独占操作
    13. class G_Lock
    14. {
    15.     public:
    16.         
    17.         /// @brief 构造函数初始化互斥锁 , 条件变量
    18.         G_Lock();

    20.         /// @brief 析构函数释放互斥锁，和条件变量
    21.         ~G_Lock();

    23.         /// @brief 读锁 readCounter++ , 锁住readCounter
    24.         void rLock();

    26.         /// @brief 解锁 readCounter-- , 如果readCounter = 0 , pthread_cond_signal通知
    27.         void unrLock();

    29.         /// @brief 写锁 如果readCounter不为0一直 pthread_cond_wait等待下去
    30.         void wLock();

    32.         /// @brief 解锁
    33.         void unwLock();
    34.     
    35.     private:
    36.         pthread_mutex_t r_Mutex; ///读锁 ，锁住readCounter

    38.         pthread_mutex_t w_Mutex; ///锁住同步资源
    39.         
    40.         unsigned long readCounter; ///条件变量如果为0通知(pthread_cond_signal)

    42.         pthread_cond_t condReadCounter;
    43. };


    46. #endif
      1. ///
      2. /// @file Lock.cpp
      3. /// @brief
      4. /// @author guozhiming
      5. /// @date 2007-04-11
      6. ///
      7. #include "Lock.h"

      9. G_Lock::G_Lock()
      10. {
      11.     pthread_mutex_init(&r_Mutex , NULL);
      12.     pthread_mutex_init(&w_Mutex , NULL);
      13.     pthread_cond_init(&condReadCounter , NULL);
      14.     readCounter = 0;
      15. }

      17. G_Lock::~G_Lock()
      18. {
      19.     pthread_mutex_destroy(&r_Mutex);
      20.     pthread_mutex_destroy(&w_Mutex);
      21.     pthread_cond_destroy(&condReadCounter);
      22. }

      24. void G_Lock::rLock()
      25. {
      26.     pthread_mutex_lock(&w_Mutex); //防止于写操作冲突
      27.     pthread_mutex_lock(&r_Mutex); //防止readCounter 冲突
      28.     readCounter++;
      29.     pthread_mutex_unlock(&w_Mutex); ///写解锁
      30.     pthread_mutex_unlock(&r_Mutex); ///读解锁
      31. }

      33. void G_Lock::unrLock()
      34. {
      35.     pthread_mutex_lock(&r_Mutex); ///读加锁
      36.     readCounter--;
      37.     if(0 == readCounter)
      38.     {
      39.         pthread_cond_signal(&condReadCounter); //如果readCounter为0 , 表示已经没有读了，可以写
      40.     }
      41.     pthread_mutex_unlock(&r_Mutex); ///读解锁
      42. }

      44. void G_Lock::wLock()
      45. {
      46.     pthread_mutex_lock(&w_Mutex); ///写加锁
      47.     pthread_mutex_lock(&r_Mutex); ///读加锁
      48.     if(0 == readCounter) ///防止readCounter = 0而且没有调用过rLock()和unrLock()
      49.     {
      50.         pthread_mutex_unlock(&r_Mutex); ///读解锁
      51.         return ;
      52.     }
      53.     pthread_cond_wait(&condReadCounter , &r_Mutex); //等待readCounter = 0 , 等待期间r_Mutex被解锁，有信号再加锁
      54.     pthread_mutex_unlock(&r_Mutex); ///读解锁
      55. }

      57. void G_Lock::unwLock()
      58. {
      59.     pthread_mutex_unlock(&w_Mutex); //写解锁
      60. }
    阅读(475) | 评论(0) | 转发(0) |
    0

    上一篇：线程同步机制

    下一篇：回调函数的概念及其使用

    给主人留下些什么吧！~~
    关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

    Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

    感谢所有关心和支持过ChinaUnix的朋友们

    16024965号-6