读和写一般是怎么处理比较妥呢？？？

Question

现在做一个监控系统，需要读(采集下位机的数据)也需要写（通过触摸屏设置参数）。  这读和写一般是怎么处理比较好？我想一个线程里面一直循环读和写。另外一个线程处理读和写的标志位。  不知道有没有更好的办法？？？

Answer 1

一个全局锁用于 每次操作为串行
TYPE_BLOCK
一个读锁，一个读增量
TYPE_RLOCK   
++r_lock;
一个写锁
TYPE_WLOCK

先使用全局锁或者使用原子锁取得CPU唯一执行权限，对数据锁位进行读写锁，读锁并增加读增量，释放全局锁或原子锁

读加锁：如果数据写锁标志有效，直接返回失败。   否则，自增读增量，防止读锁
读去锁：判断读增量个数，为0直接去掉读锁标志。  如果不为0  自减读增量，判断读增量是否为0，为0去掉读锁标志。
写加锁：判断写锁标志是否存在，存在返回失败。不存在，取得全局锁或原子锁，置放写锁标志，释放全局锁或原子锁，判断读锁标志是否存在，存在循环等待，并判断读增量是否等于0，如果等于0，去掉读锁标志，退出循环。最好加个超时等待。或者不采用循环等待，有读锁标志的时候直接返回失败！

细节部分自己去调整

Answer 2

2. char UserSrc::RLock(void**m_Packlist,  unsigned char m_Rid, unsigned long w_Time)
3. {
4.                  if( m_Packlist == NULL )
5.                 {
6.                                  return -1;
7.                 }
8.         while( (m_Packlist[m_Rid]->status & PACK_WLOCK) == PACK_WLOCK )
9.         {               
10.                 Sleep(10);
11.                 --w_Time;
12.         }
13.         if( w_Time == 0 )
14.         {
15.                 return 0;
16.         }
17.         if( m_Packlist[m_Rid]->r_lock > 253 )
18.         {
19.                 return 0;
20.         }
21.     if( Lock() != 1 )
22.         {
23.             return 0;
24.         }
25.         ++m_Packlist[m_Rid]->r_lock;
26.         m_Packlist[m_Rid]->status           |= PACK_RLOCK;
27.     Unlock();
28.         return 1;
29. }
31. char UserSrc::RUnlock(void**m_Packlist,  unsigned char m_Rid)
32. {
33.         if( m_Packlist == NULL )
34.                 {
35.                                  return -1;
36.                 }
37.     if( Lock() != 1 )
38.         {
39.             return 0;
40.         }       
41.         --m_Packlist[m_Rid]->r_lock;
42.         if( m_Packlist[m_Rid]->r_lock== 0 )
43.         {
44.                 m_Packlist[m_Rid]->status       &= ~PACK_RLOCK;
45.         }       
46.     Unlock();
47.         return 1;       
48. }
50. char UserSrc::WLock(void**m_Packlist,  unsigned char m_Rid, unsigned long w_Time)
51. {
52.         if( m_Packlist == NULL )
53.                 {
54.                                  return -1;
55.                 }
56.         if( (m_Packlist[m_Rid]->status & PACK_WLOCK) == PACK_WLOCK )
57.         {
58.                 return 0;
59.         }
60.     if( Lock() != 1 )
61.         {
62.             return 0;
63.         }
64.     m_Packlist[m_Rid]->status            |=  PACK_WLOCK;                                    //提前置放写标记，表明下一个步骤需要进行数据修改
65.     Unlock();
66.         while( (m_Packlist[m_Rid]->status & PACK_RLOCK) == PACK_RLOCK && m_Packlist[m_Rid]->r_lock != 0 )
67.         {
68.                          Sleep(1);
69.                 --w_Time;
70.         }
71.         if( w_Time == 0 )
72.         {
73.                 m_Packlist[m_Rid]->status        &= ~PACK_WLOCK;
74.                 return 0;
75.         }
76.         if( m_Packlist[m_Rid]->r_lock == 0 )
77.         {
78.                 m_Packlist[m_Rid]->status        &= ~PACK_RLOCK;
79.         }
80.         return 1;
81. }
83. char UserSrc::WUnlock(void**m_Packlist,  unsigned char m_Rid)
84. {
85.         if( m_Packlist == NULL )
86.                 {
87.                                  return -1;
88.                 }
89.     if( Lock() != 1 )
90.         {
91.             return 0;
92.         }
93.         m_Packlist[m_Rid]->status            &= ~PACK_WLOCK;
94.     Unlock();
95.         return 1;
96. }

复制代码

Answer 3

谢谢LS。研究中---

Answer 4

忘了说   这个锁的调用是先进后出  后进先出原则  
而且临界区未保护，可能有执行上的问题，你调整代码吧