2013-03-08 6 views
6

मैं इस कोड है और समझने के लिए कितने प्रक्रिया और सूत्र इस से बनाया जाएगा कोशिश कर रहा: अगर पाश अंदरकितनी प्रक्रियाएं और धागे बनाए जाएंगे?

pid t pid; 
pid = fork(); 
if (pid == 0) { /* child process */ 
fork(); 
thread create(. . .); 
} 
fork(); 

मैं इसे 2 धागे बनाता है लगता है कांटा से,। और 8 प्रक्रियाएं? लेकिन मैं निश्चित नहीं thats सही

+2

कोई लूप नहीं है। वह एक "अगर" है। – QuentinUK

+0

क्यों 8 प्रक्रियाएं? 'फोर्क' कॉल में से एक परीक्षण में है। – didierc

उत्तर

10

दरअसल, 8 धागे और 6 प्रक्रियाएं होनी चाहिए।

यहाँ चित्र है यह स्पष्ट करना:

1) after first fork(): 

    |------------------- child of p0 [p1] 
---|------------------- parent  [p0] 

2) after second fork(): 

     |--------------- child of p1 [p2] 
    |---|---------------    [p1] 
---|-------------------    [p0] 

3) after pthread_create(): 

      ----------- thread 1 of p2 [p2t1] 
     |---/----------- thread 0 of p2 [p2t0] 
     | ----------- thread 1 of p1 [p1t1] 
    |---|---/----------- thread 0 of p1 [p1t0] 
---|-------------------     [p0] 

4) after third fork(): 

     |------------ child of p2 [p5] 
     |  ------    [p2t1] 
     |-|-----/------    [p2t0] 
     | |---------- child of p1 [p4] 
     | | ------    [p1t1] 
    |---|---|---/------    [p1t0] 
    |  |------------ child of p0 [p3] 
---|-----|------------    [p0] 

महत्वपूर्ण: याद रखें कि fork(2) कॉल क्लोन सिर्फ धागा है जो इसे मार डाला है, इस प्रकार की प्रक्रिया 4 [पी 4] केवल एक धागा (समान करने के लिए लागू किया गया है प्रक्रिया 5 [पी 5])।

+0

इस सवाल से (जहाँ तक मैं बता सकता हूँ) लिया जाता है _Operating प्रणाली अवधारणाओं 9 Edition_, जो पेज 183 कि अगर पर कहा गया है "अलग प्रक्रिया (कार्यकारी फोन नहीं करता है) forking के बाद, अलग प्रक्रिया सभी धागे नकल करना चाहिए।" इसका मतलब होगा कि 10 धागे होंगे। क्या यह गलत है? यह भी कहता है कि "कुछ यूनिक्स सिस्टमों ने कांटा() के दो संस्करणों का चयन किया है, जो कि सभी थ्रेडों को डुप्लिकेट करता है और दूसरा जो केवल थ्रेड को डुप्लिकेट करता है जो फोर्क() सिस्टम कॉल को बुलाता है।" – Sammaron

+0

@ सैमरोन: [यह मैन पेज] देखें (http://pubs.opengroup.org/onlinepubs/009695399/functions/fork.html)। – jxh

7

एक अतिरिक्त प्रक्रिया हर बार fork कहा जाता है बनाया जाएगा यदि।

fork करने के लिए पहली कॉल, माता पिता प्रक्रिया पी पर उप प्रक्रिया SP1 पैदा करता है। कांटा के बाद, मूल प्रक्रिया fork फिर से कॉल करती है (if छोड़कर), उप-प्रक्रिया SP2 बनाते हैं। कांटा के बाद

SP1 fork कॉल if अंदर, बनाता उप उप प्रक्रिया SSP1। एसपी 1 फिर एक धागा पैदा करता है। एसपी 1 if छोड़ देता है। और उप-उप-प्रक्रिया एसएसपी 2 बनाने, फिर से fork पर कॉल करता है।

SSP1 एक धागा spawns। एसएसपी 1 if छोड़ देता है, और उप-सब-सब-प्रोसेस एसएसएसपी बनाने, fork पर कॉल करता है।

तो, बनाया प्रक्रियाओं: SP1, SP2, SSP1, SSP2, एसएसएसपी = 5 प्रक्रियाओं। यदि आप मूल प्रक्रिया पी को गिनते हैं, तो 6 प्रक्रियाएं होती हैं।

केवल SP1 और SSP1 अंडे धागे, इसलिए वहाँ 2 धागे बनाया जाता है। आप सभी प्रक्रियाओं के सभी मुख्य धागे गिनती करते हैं, तो 7 या 8 सूत्र, या नहीं, आप मूल प्रक्रिया पी

प्रक्रियाओं और धागे का एक उदाहरण बनाया कोड के लिए सहसंबद्ध किया जा रहा गिनती के आधार पर कर रहे हैं।

      P 
pid t pid;    | 
pid = fork();   +------SP1 
if (pid == 0) {   |  | 
fork();     |  +---------------SSP1 
thread create(...);  |  |-SP1's thread |-SSP1's thread 
}      |  |    | 
fork();     +-SP2 +-SSP2   +-SSSP 
         | | | |    | | 
0

यह 2 धागे और 6 प्रक्रियाओं नहीं होना चाहिए?

M 
| ↘ 
M  A 
|  |↘ 
M  A* B* 
|  | | 
| ↘ | ↘ |↘ 
M C A D B E 

के रूप में मैं * का उपयोग धागा प्रतिनिधित्व करने के लिए।

संबंधित मुद्दे