共享内存的多进程数据共享的一致性解决

freeeyes

最近终于有点有时间，在自己的任务日志中添加了一项
"研究多进程下共享内存数据的一致性"
经过两天的研究，写出了测试代码，并且测试通过。
很棒，解决了困扰我我好几年的一个疑惑。
不考虑windows了，Linux是我的主要开发环境。
代码如下:

1. #include <stdio.h>
2. #include <unistd.h>
3. #include <sys/ipc.h>
4. #include <sys/shm.h>
5. #include <pthread.h>
7. //add by freeeyes
8. //此测试代码，解决的是在多进程下，共享内存的安全性。
9. //测试用例是，一个进程创建10个线程，每个线程写100000次。
10. //再开两个进程，模拟多子进程写入，创造竞争机会
11. //思路，在共享内存中，记录一个pthread_mutex_t对象
12. //对这个线程锁对象添加属性，PTHREAD_PROCESS_SHARED
13. //效果不错 ^^
15. #define PERMS_IPC 0600
17. //测试类
18. struct _TestData
19. {
20.         pthread_mutex_t m_lock;
21.         int m_Data;
22.        
23.         _TestData()
24.         {
25.                 m_Data = 0;
26.         }
27. };
29. //测试共享内存下线程锁的作用
30. char * CreatShm(key_t shmkey, int length)
31. {
32.         int        shmid;
33.         char *shmp;
35.         if((shmid = shmget(shmkey, length, PERMS_IPC|IPC_CREAT)) < 0)
36.         {
37.                 return NULL;
38.         }
40.         if((shmp = (char *)shmat(shmid, (char *)0, 0)) == (char *) -1)
41.         {
42.                 return NULL;
43.         }
45.         return shmp;
46. }
48. void * threadFunc(void *arg)  
49. {  
50.    _TestData* pTestData = (_TestData* )arg;
51.    
52.    for(int i = 0; i < 100000; i++)
53.    {
54.                    //这里添加对测试数据的锁判定
55.                    pthread_mutex_lock(&pTestData->m_lock);
56.                    pTestData->m_Data++;
57.                    //usleep(1);
58.                    pthread_mutex_unlock(&pTestData->m_lock);
59.    }
60.    
61.    return ((void *)0);  
62. }  
64. int main()
65. {
66.         char* pData = CreatShm(10031, sizeof(_TestData));
67.         if(NULL == pData)
68.         {
69.                 printf("[Main]Create shm fail.\n");
70.         }
71.         else
72.         {
73.                 /* 关键在这里 */
74.                 pthread_mutexattr_t mattr;   
75.                 pthread_mutexattr_init(&mattr);   
76.                 pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_SHARED);          
77.                
78.                 pthread_mutex_t lock;       
79.                 pthread_mutex_init(&lock, &mattr);
80.                
81.                 _TestData* pTestData = (_TestData* )pData;
82.                
83.                 pTestData->m_lock = lock;
84.                 pTestData->m_Data = 0;
85.                
86.                 //创建两个子进程，模拟多进程间的数据写同步
87.                 for(int k = 0; k < 2; k++)
88.                 {
89.                         //多进程
90.                         pid_t pid = fork();
91.                
92.                         //子进程
93.                         if(pid == 0)
94.                         {
95.                                 //开始测试多线程
96.                                 pthread_t nThreadID[10];
97.                                 for(int i = 0; i < 10; i++)
98.                                 {
99.                                         pthread_create(&nThreadID[i], NULL, threadFunc, (void*)pTestData);
100.                                 }
101.                        
102.                                 for(int i = 0; i < 10; i++)
103.                                 {
104.                                         pthread_join(nThreadID[i], NULL);
105.                                 }
106.                        
107.                                 printf("[main]Data=%d.\n", pTestData->m_Data);
108.                                
109.                                 return 0;
110.                         }
111.                         printf("[main]loop end.\n");
112.                 }
113.                
114.                 printf("[main]father ok.\n");
115.         }
116.        
117.         return 0;
118. }

复制代码

此代码在Linux下测试通过。
[m2mjk@nbc testlock]$ g++ -Wall -g -rdynamic -ldl -lpthread main.cpp -o test
[m2mjk@nbc testlock]$ ./test
[main]loop end.
[main]loop end.
[main]father ok.
[main]Data=1992233.
[main]Data=2000000.