共享内存，再麻烦一下

andyY

myread.c

1. #include
   
2. 
   
3. #define        PATHNAME "/home/yz"
   
4. #define PROJID 1
   
5. #define LENGTH 5*sizeof(int)
   
6. 
   
7. void Initwrlock(struct flock *flock);
   
8. void Getwrlock(struct flock *flock);
   
9. void Releasewrlock(struct flock *flock);
   
10. 
    
11. int fd_lck;
    
12. 
    
13. int main()
    
14. {
    
15.         struct flock myflock;
    
16.         int shmid;
    
17.         key_t mykey;
    
18.         int *myshm,myshm_pre;
    
19.         struct timeval tv;
    
20. 
    
21.         //init lock
    
22.         Initwrlock(&myflock);
    
23. 
    
24.         //get key_t
    
25.         mykey = ftok(PATHNAME,PROJID);       
    
26.         if(mykey == (key_t)-1)
    
27.         {
    
28.                 perror("ftok failed ");
    
29.                 exit(errno);
    
30.         }
    
31.        
    
32.         //get shm
    
33.         shmid = shmget(mykey,LENGTH,IPC_CREAT|IPC_EXCL|00777);
    
34.         if(shmid == -1)
    
35.         {
    
36.                 if (errno == EEXIST)
    
37.                         shmid = shmget(mykey,LENGTH,0);
    
38.                 if(shmid == -1)
    
39.                 {
    
40.                         perror("shmget failed ");
    
41.                         exit(errno);
    
42.                 }
    
43.         }
    
44. 
    
45.         //attach
    
46.         myshm = (int *)shmat(shmid,NULL,0);       
    
47.         if(myshm == (int *)-1)
    
48.         {
    
49.                 perror("shmat failed ");
    
50.                 exit(errno);
    
51.         }
    
52. 
    
53.         myshm_pre = *myshm;
    
54. 
    
55.         while(1)
    
56.         {
    
57.                 //get wrlock
    
58.                 Getwrlock(&myflock);       
    
59. 
    
60.                 //read
    
61.                 if(myshm_pre != *myshm)
    
62.                 {
    
63.                         gettimeofday(&tv,NULL);
    
64.                         printf("read new :%d\ttime:%ld,%ld\n",
    
65.                                         *myshm,tv.tv_sec,tv.tv_usec);
    
66. 
    
67.                         myshm_pre = *myshm;
    
68.                 }
    
69.                        
    
70.                 //release wrlock
    
71.                 Releasewrlock(&myflock);
    
72.         }
    
73.        
    
74. }
    
75. 
    
76. void Initwrlock(struct flock *flock)
    
77. {
    
78.         fd_lck = open("./shm.lck",O_CREAT|O_RDWR,00777);
    
79.         if(fd_lck<0)
    
80.         {
    
81.                 perror("open failed ");
    
82.                 exit(errno);
    
83.         }
    
84. 
    
85.         flock->;l_whence = SEEK_SET;
    
86.         flock->;l_start = 0;
    
87.         flock->;l_len = 0;
    
88. }
    
89. 
    
90. void Getwrlock(struct flock *flock)
    
91. {
    
92.         flock->;l_type = F_WRLCK;
    
93. 
    
94.         if(fcntl(fd_lck,F_SETLKW,flock) == -1)
    
95.         {
    
96.                 perror("fcntl failed ");
    
97.                 exit(errno);
    
98.         }
    
99. }
    
100. 
     
101. void Releasewrlock(struct flock *flock)
     
102. {
     
103.         flock->;l_type = F_UNLCK;
     
104. 
     
105.         if(fcntl(fd_lck,F_SETLKW,flock) == -1)
     
106.         {
     
107.                 perror("fcntl failed ");
     
108.                 exit(errno);
     
109.         }
     
110. }

复制代码

mywrite.c

1. #include
   
2. #define        PATHNAME "/home/yz"
   
3. #define PROJID 1
   
4. #define LENGTH 5*sizeof(int)
   
5. 
   
6. void Initwrlock(struct flock *flock);
   
7. void Getwrlock(struct flock *flock);
   
8. void Releasewrlock(struct flock *flock);
   
9. 
   
10. int fd_lck;
    
11. 
    
12. int main()
    
13. {
    
14.         struct flock myflock;
    
15.         int shmid,i;
    
16.         key_t mykey;
    
17.         int *myshm;
    
18.         struct timeval tv;
    
19. 
    
20.         //init lock
    
21.         Initwrlock(&myflock);
    
22. 
    
23.         //get key_t
    
24.         mykey = ftok(PATHNAME,PROJID);       
    
25.         if(mykey == (key_t)-1)
    
26.         {
    
27.                 perror("ftok failed ");
    
28.                 exit(errno);
    
29.         }
    
30.        
    
31.         //get shm
    
32.         shmid = shmget(mykey,LENGTH,IPC_CREAT|IPC_EXCL);
    
33.         if(shmid == -1)
    
34.         {
    
35.                 if (errno == EEXIST)
    
36.                         shmid = shmget(mykey,LENGTH,0);
    
37.                 if(shmid == -1)
    
38.                 {
    
39.                         perror("shmget failed ");
    
40.                         exit(errno);
    
41.                 }
    
42.         }
    
43. 
    
44.         //attach
    
45.         myshm = (int *)shmat(shmid,NULL,0);       
    
46.         if(myshm == (int *)-1)
    
47.         {
    
48.                 perror("shmat failed ");
    
49.                 exit(errno);
    
50.         }
    
51. 
    
52.         i=0;
    
53.        
    
54.         alarm(10);
    
55.        
    
56.         while(1)
    
57.         {
    
58. 
    
59.                 //write
    
60.         //        printf("press ENTER to write new value :\n");
    
61.         //        getchar();
    
62. 
    
63.                 //get wrlock
    
64.                 Getwrlock(&myflock);       
    
65. 
    
66.                 *myshm = i;
    
67.                 gettimeofday(&tv,NULL);
    
68.                 printf("write new :%d\ttime:%ld,%ld\n",
    
69.                                 *myshm,tv.tv_sec,tv.tv_usec);
    
70. 
    
71.                        
    
72.                 //release wrlock
    
73.                 Releasewrlock(&myflock);
    
74. 
    
75.                 i = (i+1)%10000;
    
76.         }
    
77.        
    
78. }

复制代码

mywrite持续写10秒，期间myread输出只有几条，第一次 - 6条  /  二 - 1  /  三- 6 ，共享应该所有write 都能得到吧？

如果把 mywrite.c 中while 循环中得 printf & getchar 注释取消，myread倒是很快就有输出，为什么会有开始这种情况呢？

先谢过！

rabbit008

我觉得，你把printf & getchar 注释取消，那么共享内存中的值变化的就快一些，这样在读中的条件就满足的快，所以输出的快
      if(myshm_pre != *myshm)
      {
         gettimeofday(&tv,NULL);
         printf("read new :%d\ttime:%ld,%ld\n",
               *myshm,tv.tv_sec,tv.tv_usec);

         myshm_pre = *myshm;
      }

andyY

后来在while{}中加了usleep（10），所有的改变都能得到了。之前getchar被注释时可能是进程调度问题吧，只能得到很少的改变。不是太明白，先就这样再说，不知有没有深入的解释？