一个正在开发中的异步网络库 [复制链接]

论坛徽章:: 0

11楼 [报告]

发表于 2009-02-11 00:31 |只看该作者

>> 所以我的函数库里,Cond自己创建锁。
Cond自己创建锁也是可以的，C#提供了Monitor类就是这样做的，但是上面的橘子苹果的用法并不正确。

下面是C#的实现供你参考：

Monitor是mutex和condtion的组合
class Monitor {
   pthread_mutex_t mutex;
   pthread_condtion_t cond;

public:
   lock和unlock方法必须暴露出来
   void  lock()
   {
         pthread_mutex_lock(&mutex);
   }

   void unlock()
   {
         pthread_mutex_unlock(&mutex);
   }

   void wait()
   {
         pthread_cond_wait(&cond, &mutex);
   }

   void signal()
   {
         pthread_cond_signal(&cond);
   }
}

C#中使用Monitor的模式是：

Monitor monitor; Monitor是mutex和condtion的组合

monitor.lock();
wait不需要有mutex参数了，但是monitor.cond仍然是受到monitor.mutx的保护
while (期待的条件 == FALSE)
monitor.wait();

assert(期待的条件 == 真);
do somthing;

monitor.unlock();

C语言中使用conditon的模式：

mutex.lock();
while (期待的条件 == FALSE)
condition.wait(&mutex);
assert(期待的条件 == 真);
do somthing;
mutex.unlock();

复制代码

把C#的代码展开后，可以发现C#的方法和传统POSIX的方法原理上是完全一样的，总之，condition也是共享资源，和fruits一样，也需要受到mutex的保护，禁止多个线程同时访问。

[ 本帖最后由 CRLF 于 2009-2-11 00:36 编辑 ]

实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？

die

白手起家

论坛徽章:: 0

12楼 [报告]

发表于 2009-02-11 00:35 |只看该作者

#ifndef  COND_HPP
#define  COND_HPP

//
// Cond.hpp
// ~~~~~~~~~~~~~~~~
//
// @author <zhuxueling@pica.com>
// @data 2009-02-05

#include <pthread.h>
#include "Lock.hpp"
#include "Mutex.hpp"

namespace Traxex{
class Cond{
public:
Cond():lock_( mutex_){
int stat = pthread_cond_init( &cond_, 0);
if( stat !=0 ){
      throw Error( COND_CREATE_ERR);
}
}
virtual ~Cond(){
pthread_cond_destroy( &cond_);
}

bool wait( bool lock = true){
if( lock){
      bool stat = lock_.do_lock();
      if( !stat) return false;
}

int wait_stat = pthread_cond_wait( &cond_,& mutex_.mutex_);

if( lock){
      lock_.unlock();
}
if( wait_stat != 0) return false;
return true;
}

bool time_wait( double sec, bool lock = true){
if( lock){
      bool stat = lock_.do_lock();
      if( !stat) return false;
}

int  sec_  = (int)( sec);
int  nsec_ = (int)( (sec * 1000000) - sec_ * 1000000);
timespec timeout={ sec_, nsec_};
int wait_stat = pthread_cond_timedwait( &cond_, &mutex_.mutex_, &timeout);

if( lock){
      lock_.unlock();
}
if( wait_stat != 0) return false;
return true;
}
bool signal( bool one = true){
int stat;
if( one){
      stat = pthread_cond_signal( &cond_);
}else{
      stat = pthread_cond_broadcast( &cond_);
}
if( stat !=0 ) return false;
return true;
}

bool lock(){
return lock_.do_lock();
}
bool unlock(){
return lock_.unlock();
}
private:
Mutex mutex_;
Lock lock_;
pthread_cond_t cond_;
};
};
#endif //COND_HPP

[ 本帖最后由 die 于 2009-2-11 00:40 编辑 ]

实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？

CRLF

白手起家

论坛徽章:: 0

13楼 [报告]

发表于 2009-02-11 00:41 |只看该作者

原帖由 die 于 2009-2-11 00:23 发表
ScopeLock lock( mutex);
这个不是一个局部锁么。。。
出作用域自动解锁的。

但是下面的代码中，有可能出现add线程执行cond.signal、eat线程执行cond.wait的情况，cond和fruits vector一样都是属于共享资源，不能被多个线程同时访问。

void add(string name){
while( true){
      ScopeLock lock( mutex);
      fruits.push(name);
      std::cout << "add " << name << std::endl;
      执行到这里：cond.signal(); cond是共享资源!
      Sleep( 200);
}
}

void eat( ){
while( true){
      执行到这里：cond.wait(); cond是共享资源!
      ScopeLock lock( mutex);
      fruits.pop();
      std::cout << "eat "<< fruits.front() << std::endl;
}
}