OpenThreads共享资源保护的问题

brucefeng

最近在开发的过程中涉及到两个线程对同一个内存数据进行操作，写了一段实验代码，结果完全达不到效果。

1. class MetaData
   
2. {
   
3. public:
   
4.         MetaData(void);
   
5.         MetaData(int dataArray[10]);
   
6.         ~MetaData(void);
   
7.         void setDataArray(int dataArray[10]);
   
8.         void setDataArray(int index,int value);
   
9.         int* getDataArray();
   
10.         int getDataArray(int index);
    
11. private:
    
12.         int dataArray[10];
    
13. 
    
14. };       

复制代码

这个是要操作的元数据。
写了两个线程，WriteThread和ReadThread来实现对元数据的读写操作。

1. class WriteThread :
   
2.         public OpenThreads::Thread
   
3. {
   
4. public:
   
5.         WriteThread(void);
   
6.         WriteThread(int index,int value,MetaData* metaData);
   
7.         ~WriteThread(void);
   
8.         virtual int cancel();
   
9.         virtual void run();
   
10.        
    
11. private:
    
12.         int index,value;
    
13.         MetaData* metaData;
    
14.         OpenThreads::Mutex wirteMutex;
    
15. };
    

复制代码

1. class ReadThread :
   
2.         public OpenThreads::Thread
   
3. {
   
4. public:
   
5.         ReadThread(void);
   
6.         ReadThread(int index,MetaData* metaData);
   
7.         ~ReadThread(void);
   
8.         virtual void run();
   
9.         virtual int cancel();
   
10. private:
    
11.         OpenThreads::Mutex readMutex;
    
12.         int index;
    
13.         MetaData* metaData;
    
14. };
    

复制代码

两个线程类的Run函数分别为：

1. void WriteThread::run()
   
2. {
   
3.         OpenThreads::ScopedLock<OpenThreads::Mutex> wirterLock(this->wirteMutex);
   
4.         for(int i=0;i<10;i++)
   
5.         {
   
6.                 std::cout<<"write is running "<<std::endl;
   
7.                 this->metaData->setDataArray(this->index,this->value);
   
8.                 this->microSleep(150000L);
   
9.         }
   
10.        
    
11. }

复制代码

1. void ReadThread::run()
   
2. {
   
3.         OpenThreads::ScopedLock<OpenThreads::Mutex> readLock(this->readMutex);
   
4.        
   
5.         for(int i=0;i<10;i++)
   
6.         {
   
7.                 std::cout<<"read is running"<<std::endl;
   
8.                 //this->metaData->setDataArray(this->index,3);
   
9.                 std::cout<<"the "<<this->index<<" value is "<<this->metaData->getDataArray(this->index)<<std::endl;
   
10. 
    
11.                 this->microSleep(150000L);
    
12.         }
    
13.        
    
14.        
    
15.        
    
16. 
    
17. }

复制代码

主函数里面的调用为：

1. int main()
   
2. {
   
3.        
   
4.        
   
5.         MetaData* metaData = new MetaData();
   
6.         int index = 0,value = 10;
   
7.         WriteThread write(index,value,metaData);
   
8.         ReadThread read(index,metaData);       
   
9.         read.start();
   
10.         write.start();
    
11. ｝
    

复制代码

本来想实现read线程读取完毕之后，write线程才可以操作元数据，结果这样写了之后发现两者是同时运行的。
本文对多线程了解不深，望高人指点。

fenma3422

你没有进行任何同步。你可以使用事件通知机制，当读完后通知写线程，读线程停止等待写读事件。
写线程收到写事件后，进行写操作，写完后通知读线程开始读！

brucefeng

fenma3422 发表于 2012-3-26 18:36
你没有进行任何同步。你可以使用事件通知机制，当读完后通知写线程，读线程停止等待写读事件。
写线程收到 ...

我就是想知道怎么去同步……

fenma3422

你可以使用事件通知机制，当读完后通知写线程，读线程停止等待写读事件。
写线程收到 ...

brucefeng

fenma3422 发表于 2012-3-27 09:47

问题已经找到了，原来是读锁和写锁必须使用同一个Mutex才可以达到同步到目的。另外发现OpenThreads里面也具有ReadWriteMutex，可以很好的实现我上面索要实现的东西。
这里面没有使用事件机制主要是因为只是个demo,需要通过这个demo研究一下多线程的问题。真实运行的时候可能有好几个read线程，还会有其他的模型构造线程。

foeming

学习了，谢谢分享。