2 condition & mutex

目录

1、概述

2、Mutex

3、Condition

 

1 概述

---

互斥量和条件变量在开发多线程应用中经常用到。

Linux提供了pthread_mutex_t pthread_cond_t及对应的操作使得用户可以方便的使用这两种机制（不了解的可以去百度下)。

Mutex和Condition是android代码中对pthread_mutex_t和pthread_cond_t 的封装，可以认为功能是一样的，只是调用方式上有些差别

当然Mutex和Condition具有更好的可操作性

 

2 Mutex

---

2.1 例子

这里通过一个小的例子，介绍如何利用Mutex方法进行互斥操作

//for mutex test        public:        Mutex mLock;        int exit_flag;        int read_exit;        int write_exit;          int mutex_test_start();        int mutex_test_stop();        static int thread_read(void *);        static int thread_write(void *);

这里介绍下头文件中定义的相关的变量。exit_flag表示是否退出测试，read_exit表示读取线程成功退出标记  write_exit表示写线程成功退出标志

定义了两个线程函数thread_read thread_write，一个Mutex变量mLock，在线程代码中循环获取mLock，执行某些操作，最后退出

其中mutex_test_start和mutex_test_stop控制测试的开始和结束，下面看下实现

int dtPlayer::mutex_test_start(){      exit_flag=0;      read_exit=0;      write_exit=0;      createThread(thread_read,this);        createThread(thread_write,this);       printf("--thread start ok\n");       return 0;    }

启动线程，并初始化变量

int dtPlayer::mutex_test_stop(){      exit_flag=1;    LOOP:      if(read_exit&&write_exit)        return 0;      sleep(1);      goto LOOP;    }

判断是否都成功退出

int dtPlayer::thread_read(void *user){      dtPlayer *player=(dtPlayer *)user;      while(player->exit_flag==0)      {        player->mLock.lock();        printf("thread read is running \n");        sleep(2);        player->mLock.unlock();        sleep(1);      }      printf("--read thread exit ok\n");      player->read_exit=1;      return 0;      }

读线程，首先通过lock获取锁，获取成功后打印消息"thread read is running" 然后解锁，sleep 1s后重新去获取锁

int dtPlayer::thread_write(void * user){      dtPlayer *player=(dtPlayer *)user;      while(player->exit_flag==0)      {        player->mLock.lock();        printf("thread write is running \n");        sleep(2);        player->mLock.unlock();        sleep(1);      }      printf("--write thread exit ok\n");      player->write_exit=1;      return 0;    }

写线程与读线程类似，这里主要是为了模拟两个线程竞争同一把锁的情况，以及对Mutex的使用有个直观的认识

extern "C" int dt_mutex_test()    {        ALOGE("--mutex test before \n");        dtPlayer *player=new dtPlayer();        player->mutex_test_start();        sleep(20);        player->mutex_test_stop();        ALOGE("--mutex test end \n");        return 0;    }

最后是入口函数

2.2 Mutex类介绍

通过上面例子，可以了解Mutex的使用非常简单即如下序列：

Mutex mMux;    mMux.lock();    **user ops**    mMux.unlock();

下面介绍Mutex的定义等

源文件在framework/native/include/utils/Mutex.h中

主要有如下重要方法，首先是构造函数

inline Mutex::Mutex() {       pthread_mutex_init(&mMutex, NULL);   }   inline Mutex::Mutex(const char* name) {       pthread_mutex_init(&mMutex, NULL);   }   inline Mutex::Mutex(int type, const char* name) {       if (type == SHARED) {           pthread_mutexattr_t attr;           pthread_mutexattr_init(&attr);           pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);           pthread_mutex_init(&mMutex, &attr);           pthread_mutexattr_destroy(&attr);       } else {           pthread_mutex_init(&mMutex, NULL);       }   }

这里给出了三种构造函数，之前介绍过，Mutex仅仅是对pthread_mutex_t及其操作的封装，因此构造函数是初始化的封装

inline status_t Mutex::lock() {       return -pthread_mutex_lock(&mMutex);   }   inline void Mutex::unlock() {       pthread_mutex_unlock(&mMutex);   }   inline status_t Mutex::tryLock() {       return -pthread_mutex_trylock(&mMutex);   }

同理，lock等也比较简单

inline Mutex::~Mutex() {       pthread_mutex_destroy(&mMutex);   }

析构函数

下面介绍Mutex中一个比较方便的扩展：

class Autolock {   public:       inline Autolock(Mutex& mutex) : mLock(mutex)  { mLock.lock(); }       inline Autolock(Mutex* mutex) : mLock(*mutex) { mLock.lock(); }       inline ~Autolock() { mLock.unlock(); }   private:       Mutex& mLock;   };

Autolock封装了Mutex相关的操作，其优点在于会在Autolock生命周期到期调用析构函数的时候会调用相应Mutex的unlock方法，这样用户就不用时刻惦记着unlock了

在使用的时候，是要配合一个已经存在的Mutex变量来使用，举例如下

Mutex mutex;    int dtPlayer::test()    {        Mutex::Autilock lock(mutex);        ***user ops***        return 0;    }

使用非常方便。最主要的优点是不用惦记unlock

【说明】例子可从附件获得

3 Condition

---

3.1 例子

//for condition test  public:      Condition mCondition;      Mutex mMuxCon;      int resource_count;      int inc_exit;      int dec_exit;      int condition_test_start();      int condition_test_stop();      static int thread_inc(void *);      static int thread_dec(void *);

这里同样主体是两个线程，thread_inc thread_dec，resource_count是资源数量，当数量==0时，thread_dec会进入等待，等待thread_inc增加资源数量

看下实现

int dtPlayer::condition_test_start()  {          resource_count=0;          inc_exit=0;          dec_exit=0;          createThread(thread_dec,this);           createThread(thread_inc,this);            printf("--thread start ok\n");           return 0;  }    int dtPlayer::condition_test_stop()  {  LOOP:    if(inc_exit&&dec_exit)      return 0;    sleep(1);    goto LOOP;      return 0;  }

初始化和结束实现，比较简单

int dtPlayer::thread_dec(void *user)  {        dtPlayer *player=(dtPlayer *)user;        player->mMuxCon.lock();        while(player->resource_count==0)        {              printf("start wait  \n");                player->mCondition.wait(player->mMuxCon);        }        player->resource_count--;        printf("decremen resource count  \n");          player->mMuxCon.unlock();        player->dec_exit=1;        return 0;  }

资源递减线程，首先获取互斥锁，然后判断资源数量，如果资源数量==0，则调用wait方法，wait参数是互斥锁，如果了解pthread_cond_t操作可以知道，wait会释放互斥锁

然后等待条件变量被激活，当被激活时会重新锁住，然后继续执行。也就是说这里wait会释放player->mMuxCon互斥锁

int dtPlayer::thread_inc(void *user)  {        dtPlayer *player=(dtPlayer *)user;        player->mMuxCon.lock();        if(player->resource_count==0)        {              printf("increment resource count  \n");                player->mCondition.signal();        }        player->resource_count++;        player->mMuxCon.unlock();        player->inc_exit=1;        return 0;  }

资源递增线程同样也是先获取锁，然后判断资源数量，如果发现count==0，则发送信号，此时可能有资源消耗线程等待，同时调用player->resource_count++; 增加资源

这里可以得出结论wait会释放锁，因为如果不释放则当数量==0时，thread_inc将无法得到锁

extern "C" int dt_condition_test()  {      ALOGE("--condition test before \n");      dtPlayer *player=new dtPlayer();      player->condition_test_start();      player->condition_test_stop();      ALOGE("--condition test end \n");      return 0;  }

最后是测试入口

【说明】例子在附件中

3.2 Condition类介绍

下面介绍下Condition类

源文件：framework/native/include/utils/Condition.h

Condition();      Condition(int type);      ~Condition();      // Wait on the condition variable.  Lock the mutex before calling.      status_t wait(Mutex& mutex);      // same with relative timeout      status_t waitRelative(Mutex& mutex, nsecs_t reltime);      // Signal the condition variable, allowing one thread to continue.      void signal();      // Signal the condition variable, allowing all threads to continue.      void broadcast();    private:  #if defined(HAVE_PTHREADS)      pthread_cond_t mCond;  #else    void*   mState;  #endif

 重要的方法及成员，都是围绕mCond也就是pthread_cond_t展开，看下具体实现

inline Condition::Condition() {      pthread_cond_init(&mCond, NULL);  }  inline Condition::Condition(int type) {      if (type == SHARED) {          pthread_condattr_t attr;          pthread_condattr_init(&attr);          pthread_condattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);          pthread_cond_init(&mCond, &attr);          pthread_condattr_destroy(&attr);      } else {          pthread_cond_init(&mCond, NULL);      }  }  inline Condition::~Condition() {      pthread_cond_destroy(&mCond);  }

构造函数==初始化

inline status_t Condition::wait(Mutex& mutex) {     return -pthread_cond_wait(&mCond, &mutex.mMutex); }

wait函数

inline void Condition::signal() {     pthread_cond_signal(&mCond); } inline void Condition::broadcast() {     pthread_cond_broadcast(&mCond); }

唤醒函数，signal和broadcast的区别是signal只唤醒一个线程，而boradcast将唤醒所有线程

【结束】