如何限制同一时刻的fork的最大数量?一定要用共享内存吗?

sz00

我修改了一下,但是运行还是不对,不知道哪里错了

1. 
   
2. #include        <stdio.h>;
   
3. #include        <stdlib.h>;
   
4. #include        <time.h>;
   
5. #include        <unistd.h>;
   
6. #include        <sys/types.h>;
   
7. #include        <sys/ipc.h>;
   
8. #include        <sys/shm.h>;
   
9. 
   
10. main()
    
11. {
    
12.         int        fknbr = 0;
    
13.         key_t        key;
    
14.         int        shmid;
    
15.         int        ret;
    
16.         char        *shmbuf;
    
17. 
    
18.         key = ftok( "/", 'J' );
    
19.         if( key == -1 )
    
20.         {
    
21.                 fprintf( stderr, "ftok() failed!\n" );
    
22.                 return ;
    
23.         }
    
24. 
    
25.         shmid = shmget( key, 1024, IPC_CREAT | 0666 );
    
26.         if( shmid == -1 )
    
27.         {
    
28.                 fprintf( stderr, "Get shared memory failed!\n" );
    
29.                 return ;
    
30.         }
    
31. 
    
32.         shmbuf = NULL;
    
33.         shmbuf = shmat( shmid, NULL, 0 );
    
34.         if( shmbuf == NULL )
    
35.         {
    
36.                 fprintf( stderr, "Attach shared memory failed!\n" );
    
37.                 return;
    
38.         }
    
39. 
    
40.         sprintf( shmbuf, "%d", fknbr );
    
41.         fprintf( stderr, "Shared memory writed success![%s]\n", shmbuf );
    
42. 
    
43.         ret = shmdt( shmbuf );
    
44.         if( ret == -1 )
    
45.         {
    
46.                 fprintf( stderr, "Detach shared memory failed!\n" );
    
47.                 return;
    
48.         }
    
49. 
    
50.         for( ; ; )
    
51.         {
    
52.                 shmbuf = shmat( shmid, NULL, SHM_RDONLY );
    
53.                 if ( shmbuf == NULL )
    
54.                 {
    
55.                         fprintf( stderr, "Attach shared memory failed!\n" );
    
56.                         return;
    
57.                 }
    
58. 
    
59.                 fknbr = atoi( shmbuf );
    
60.                 fprintf( stderr, "Read from shmbuf fknbr=[%d]\n", fknbr );
    
61. 
    
62.                 ret = shmdt( shmbuf );
    
63.                 if ( ret == -1 )
    
64.                 {
    
65.                         fprintf( stderr, "Detach shared memory failed!\n" );
    
66.                         return;
    
67.                 }
    
68. 
    
69.                 if( fknbr >; 3 )
    
70.                 {
    
71.                         printf( "Busy now! fknbr:[%d]\n", fknbr );
    
72.                         sleep( 5 );
    
73.                 }
    
74. 
    
75.                 if( ( fork() == 0 ) && ( fknbr < 4 ) )
    
76.                 {
    
77.                         fknbr++;
    
78.                         printf( "Process fknbr:[%d]\n", fknbr );
    
79.                         sleep( 3 );
    
80.                         fknbr--;
    
81. 
    
82.                         shmbuf = NULL;
    
83.                         shmbuf = shmat( shmid, NULL, 0 );
    
84.                         if( shmbuf == NULL )
    
85.                         {
    
86.                                 fprintf( stderr, "Attach shared memory failed!\n" );
    
87.                                 return;
    
88.                         }
    
89. 
    
90.                         sprintf( shmbuf, "%d", fknbr );
    
91.                         fprintf( stderr, "Shared memory writed success in Process![%s]\n", shmbuf );
    
92. 
    
93.                         ret = shmdt( shmbuf );
    
94.                         if( ret == -1 )
    
95.                         {
    
96.                                 fprintf( stderr, "Detach shared memory failed!\n" );
    
97.                                 return;
    
98.                         }
    
99. 
    
100.                         exit( 0 );
     
101.                 }
     
102. 
     
103.         }
     
104. }
     

复制代码

刚看了看共享内存,抄了一段,好像不太对,不知道哪里错了

JohnBull

这种场合不适合使用共享内存，因为你没有合适的阻塞手段。
你可以利用信号灯定义出PV操作，然后在fork之前调用P操作，如果信号灯的值等于零，进程会自然阻塞，直到有哪个子进程推出之前调用V操作为止。
这个地方不要考虑shm，不合适，太麻烦！

修改：不是不合适，而是根本就不应该使用shm。shm只能提供数据通讯，不能实现互斥。

伪代码定义：

1. 
   
2. ……
   
3. P()
   
4. {
   
5.         信号量--; /*用semop()实现*/
   
6. }
   
7. 
   
8. V()
   
9. {
   
10.         信号量++; /*用semop()实现*/
    
11. }
    
12. 
    
13. 初始化信号量=50；
    
14. for (i=0;i<1000;i++) {
    
15.         P();  /* 当信号量=0时，这里会自然阻塞！ */
    
16.         if (fork()==0) {
    
17.                 做点事情；
    
18.                 V();
    
19.                 exit(0);
    
20.         }
    
21. }
    
22. ……
    

复制代码

liuyanghr

刚看了看共享内存,抄了一段,好像不太对,不知道哪里错了

你没有将改变的数字写回去