help如何使用信号量避免文件读写冲突(基本功能实现，但仍有疑惑)

车太咸

2个进程同时读写一个文件会产生冲突
我想利用信号量来控制
我设想的步骤:

1.create一个信号量
2.P操作
3.读写文件
4.V操作

我临时网络上找的一些信号量的知识，没怎么看明白
希望哪位前辈能抽时间点拨下
能否给个伪代码
先谢谢了！

我使用的系统是：Linux test237 2.6.9-55.ELsmp #1 SMP Fri Apr 20 16:36:54 EDT 2007 x86_64 x86_64 x86_64 GNU/Linux

参考 unix网络编程：卷2 255页的程序，锁的功能已经实现了，但是遇到2个问题不明白
1. 该行代码有疑惑 if(arg.buf->sem_otime != 0)    //这里sem_otime == 0（按书上说的如果该值不为0，表示创建该信号灯的进程已对它初始化，继续为0的情况很罕见..）
2：/tmp/sem 文件是我手动创建的..这样对吗？

1. 
   
2. #include <sys/ipc.h>
   
3. #include <sys/sem.h>
   
4. #include <stdio.h>
   
5. #include <unistd.h>
   
6. #include <errno.h>
   
7. #include <semaphore.h>
   
8. 
   
9. #define LOCK_PATH       "/tmp/sem"
   
10. #define MAX_TRIES       10      
    
11. #define repline() do{ printf("%d", __LINE__); fflush(stdout); }while(0)
    
12. 
    
13. union semun {
    
14.         int     val;   
    
15.         struct semid_ds *buf;
    
16.         unsigned short  *array;
    
17. };
    
18. 
    
19. int             semid, initflag;
    
20. struct sembuf   postop, waitop;
    
21. 
    
22. 
    
23. int
    
24. my_lock(void)
    
25. {
    
26.         int             oflag, i;
    
27.         key_t           semkey;
    
28.         union semun     arg;   
    
29.         struct semid_ds seminfo;
    
30. 
    
31.         if(initflag == 0) {
    
32.                 if( (semkey = ftok(LOCK_PATH, 0)) == -1) {
    
33.                         repline();
    
34.                         perror("[ftok]");
    
35.                         return -1;
    
36.                 }      
    
37.                         
    
38.                 oflag = IPC_CREAT | IPC_EXCL | 0777;
    
39.                 if( (semid = semget(semkey, 1, oflag)) >=0) {
    
40.                         arg.val = 1;
    
41.                         if(semctl(semid, 0, SETVAL, arg) < 0) {
    
42.                                 repline();
    
43.                                 perror("[semctl]");
    
44.                         }      
    
45.                 } else if(errno == EEXIST) {
    
46.                         if( (semid = semget(semkey, 1, 0777)) < 0) {
    
47.                                 repline();
    
48.                                 perror("[semget]");
    
49.                                 return -1;
    
50.                         }      
    
51.                         arg.buf = &seminfo;
    
52.                         for(i = 0; i < MAX_TRIES; i++) {
    
53.                                 if(semctl(semid, 0, IPC_STAT, arg) < 0) {
    
54.                                         repline();
    
55.                                         perror("[semctl]");
    
56.                                         return -1;
    
57.                                 }
    
58.                             if(arg.buf->sem_otime != 0)    //这里sem_otime == 0
    
59.                                         goto init;
    
60.                                 sleep(1);
    
61.                         }
    
62.                         repline();
    
63.                         printf("time out\n");
    
64.                         return -1;
    
65.                 } else
    
66.                         repline();
    
67.                         return -1;
    
68. init:
    
69.         initflag = 1;
    
70.         postop.sem_num = 0;
    
71.         postop.sem_op = 1;
    
72.         postop.sem_flg = SEM_UNDO;
    
73. 
    
74.         waitop.sem_num = 0;
    
75.         waitop.sem_op = -1;
    
76.         waitop.sem_flg = SEM_UNDO;
    
77.         }
    
78.         if( semop(semid, &waitop, 1) < 0) {
    
79.                 repline();
    
80.                 perror("[semop]");
    
81.                 return -1;
    
82.         }
    
83. 
    
84.         return 0;
    
85. }
    
86. 
    
87. int
    
88. my_unlock(void)
    
89. {
    
90.         if( semop(semid, &postop, 1) < 0) {
    
91.                 repline();
    
92.                 perror("[semop]");
    
93.                 return -1;
    
94.         }
    
95.         return 0;
    
96. }
    
97. 
    
98. int
    
99. main()
    
100. {
     
101.          my_lock();
     
102.          /*读写文件*/
     
103.          my_unlock();
     
104.          return 0;
     
105. }
     
106. 
     

复制代码

[ 本帖最后由 车太咸 于 2007-11-23 15:10 编辑 ]

车太咸

zijian1984

是不是一个进程读写完了以后，用个kill发一个SIGUSER1,信号给另一个进程，那个进程只有捕获到这个信号才可以读写，反之亦然。
ps:为什么不用锁机制？

车太咸

原帖由 zijian1984 于 2007-11-22 15:02 发表
是不是一个进程读写完了以后，用个kill发一个SIGUSER1,信号给另一个进程，那个进程只有捕获到这个信号才可以读写，反之亦然。
ps:为什么不用锁机制？

我理解的意思：
先建立一个信号量给它赋值0

进程读写文件前判断信号量的值
如果为1就等待
如果为0就将值改成1
然后进行文件读写操作
文件操作完毕后将信号量值改成0

在我目前的情况下用锁不方便，程序变动要大点

ps：貌似技术区域很冷清 水区很火爆...

[ 本帖最后由 车太咸 于 2007-11-22 15:11 编辑 ]

车太咸

网络编程的书没带
下了个pdf的又不全

继续啃
麻烦路过的达人点拨下 不胜感激

zi_ji

你的思路没啥问题
实现吧

车太咸

原帖由 zi_ji 于 2007-11-22 15:17 发表
你的思路没啥问题
实现吧

就是不知道怎么实现....

那几个函数我很晕
semget
semctl
看man手册 e文烂 晕忽忽的

能告诉我每个步骤用哪些函数吗？

车太咸

用semget可以建立一个信号量
用semctl可以给信号量赋值
那判断信号量的值要什么函数实现呢？怎么使进程等待？
还有就是万一进程在信号量的值没有复位前就异常中断了，那怎么办？

ruchong

两个进程是两个程序吗.....
可以考虑用管道
进程A阻塞住收到进程B的消息可以读文件...
然后进程B在阻塞住收到进程A的消息，在读文件

车太咸

原帖由 ruchong 于 2007-11-22 15:32 发表
两个进程是两个程序吗.....
可以考虑用管道
进程A阻塞住收到进程B的消息可以读文件...
然后进程B在阻塞住收到进程A的消息，在读文件

是2个独立的程序

谢谢关注...