信号灯建立后，锁定它没有反应，直到我将informix关闭后才执行

zhoulongfei

//锁定信号灯
void P(int sem_set_id)
{
        struct sembuf sem_op;

        //等待信号灯, 直到它的数值非负数
        sem_op.sem_num = 0;
        sem_op.sem_op = -1;
        sem_op.sem_flg = 0;
        semop(sem_set_id, &sem_op, 1);
    printf("锁定信号灯";
}//end of P()

运行到semop(sem_set_id, &sem_op, 1);就没有反映了

flw

你用的是什么系统？

zhoulongfei

sco unix 5.05

无双

是不是其它地方使用了这个信号灯
然后没有释放呢

检查一政代码看看

zhoulongfei

如果是程序的其他地方调用了，不应该把INFORMIX关了就好了呀

zhoulongfei

//建立信号灯
        sem_set_id = semget(SEM_ID, 1, IPC_CREAT | 0600);
        if (sem_set_id == -1) {
                perror("main: semget";
                exit(1);
        }

        //设置信号灯的数值是 1
        sem_val.val = 1;
        rc = semctl(sem_set_id, 0, SETVAL, sem_val);
        if (rc == -1) {
                perror("main: semctl";
                exit(1);
        }

flw

我怀疑你是不是没有搞清楚信号灯是怎么回事？
恕我冒昧，给你贴一个 demo 程序，希望对你有用：

1. 这个例子演示了信号量的一种用法, 即利用信号量实现资源的互斥访问.
   
2. 
   
3. 例子使用方法:
   
4. $ one & another
   
5. 
   
6. 程序 one.c 首先建立一个信号量集合, 其中包含了一个信号量, 然后调用
   
7. 
   
8.         semop( semid, &FREE, 1 );
   
9. 
   
10. 使资源可用. 接下来是一个循环处理 ---- 这是许多后台进程的典型结构 ---- 用来代表反复的对这个资源的访问请求. 在这个循环中, 每次访问资源前首先使用语句
    
11. 
    
12.         semop( semid, &GET, 1 );
    
13. 
    
14. 获得对资源的使用权(注1), 然后开始访问资源, 访问完毕后释放(注2).
    
15. 程序 another.c 代表另外一个与 one.c 竞争使用互斥资源的进程, 它的流程与 one.c 完全相同.
    
16. 
    
17. 
    
18. 注1:   这是书本中的说法, 就我理解, 该语句实际上只是将信号量的 semval 减一, 由于这两个程序的流程的特点, 该操作也就是将 semval 置为零. 换句话说, "获得使用权" 实际上是建立在 "自觉" 的基础上的, 即使是你将 semval 置为零, 互斥资源仍然可以访问.
    
19.        由于当 semval 为零时 semop( semid, &GET, 1 ) 调用将导致进程阻塞, 所以实现了 "当资源正被另一个进程使用(semval=0)时, 请求互斥使用资源的进程将等待(阻塞)".
    
20. 
    
21. 注2:   也就是将 semval 加一, 使之可用.
    
22. 
    
23. 总的来说, 信号量实现了一个原子性的操作, 从而使程序之间的协调变得格外容易.
    

复制代码

1. .c.o:
   
2.         cc -c $<
   
3. 
   
4. All:        TestSem clean
   
5. 
   
6. main:        main.o
   
7.         cc -o main main.o
   
8. 
   
9. TestSem:        one another
   
10. 
    
11. one:        one.o
    
12.         cc -o one one.o
    
13. 
    
14. another:        another.o
    
15.         cc -o another another.o -l curses
    
16. 
    
17. clean:
    
18.         if [ -f *.o ]; then rm *.o; fi
    
19. 
    

复制代码

1. //
   
2. // filename: one.c
   
3. // writer:   flw
   
4. //
   
5. 
   
6. # include <unistd.h>;
   
7. # include <stdio.h>;
   
8. # include <sys/ipc.h>;
   
9. # include <sys/sem.h>;
   
10. 
    
11. struct sembuf GET  = { 0, -1, SEM_UNDO };
    
12. struct sembuf FREE = { 0,  1, SEM_UNDO };
    
13. struct sembuf TEST = { 0,  0, SEM_UNDO };
    
14. 
    
15. void main( void )
    
16. {
    
17.         int semid, ret;
    
18.         key_t key;
    
19. 
    
20.         key = ftok( "/", 'J' );
    
21.         if ( key == -1 )
    
22.         {
    
23.                 fprintf( stderr, "Ftok() Failed!\n" );
    
24.                 return;
    
25.         }
    
26. 
    
27.         semid = semget( key, 1, IPC_CREAT | 0666 );
    
28.         if ( semid == -1 )
    
29.         {
    
30.                 fprintf( stderr, "Semget() Failed!\n" );
    
31.                 return;
    
32.         }
    
33.        
    
34.         fprintf( stderr, "One Begin...\n" );
    
35. 
    
36.         semop( semid, &FREE, 1 );
    
37. 
    
38.         while(1)
    
39.         {
    
40.                 semop( semid, &GET, 1 );
    
41.                 fprintf( stderr, "one: 开始访问资源!\n" );
    
42.                 sleep( 1 );
    
43.                 // 访问互斥资源
    
44.                 fprintf( stderr, "one: 资源访问结束!\n" );
    
45.                 semop( semid, &FREE, 1 );
    
46.                 sleep( 2 );
    
47.         }
    
48. }
    

复制代码

1. //
   
2. // filename: another.c
   
3. // writer:   flw
   
4. //
   
5. 
   
6. # include <unistd.h>;
   
7. # include <stdio.h>;
   
8. # include <sys/ipc.h>;
   
9. # include <sys/sem.h>;
   
10. # include <curses.h>;
    
11. 
    
12. struct sembuf TEST = { 0,  0, SEM_UNDO };
    
13. struct sembuf GET  = { 0, -1, SEM_UNDO };
    
14. struct sembuf FREE = { 0,  1, SEM_UNDO };
    
15. 
    
16. void main( void )
    
17. {
    
18.         int semid, ret;
    
19.         key_t key;
    
20. 
    
21.         key = ftok( "/", 'J' );
    
22.         if ( key == -1 )
    
23.         {
    
24.                 fprintf( stderr, "Ftok() Failed!\n" );
    
25.                 return;
    
26.         }
    
27. 
    
28.         semid = semget( key, 1, IPC_CREAT | 0666 );
    
29.         if ( semid == -1 )
    
30.         {
    
31.                 fprintf( stderr, "Semget() Failed!\n" );
    
32.                 return;
    
33.         }
    
34.        
    
35.         fprintf( stderr, "Another Begin...\n" );
    
36. 
    
37.         while(1)
    
38.         {
    
39.                 sleep( 10 );
    
40.                 semop( semid, &GET, 1 );
    
41.                 fprintf( stderr, "another: 开始访问资源\n" );
    
42.                 // 访问互斥资源
    
43.                 sleep( 6 );
    
44.                 fprintf( stderr, "another: 资源访问结束!\n" );
    
45.                 semop( semid, &FREE, 1 );
    
46.         }
    
47. }
    

复制代码

zhoulongfei

我原来是不太明白信号灯的原理，但是操作系统中的P V 操作我理解和这比较相似
能不能看看我的问题出在那里

flw

[quote]原帖由 "zhoulongfei"]信号灯建立后，锁定它没有反应[/quote 发表：

什么叫“没有反应”？
拜托大哥把问题说清楚一点！

无双

没有代码怎么看
检查一下

1  semget 得到
2  semctl  设置初始值

3 semop 操作