कितनी प्रक्रियाएं और धागे बनाए जाएंगे?

Question

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

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

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

Answer 1

दरअसल, 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])।

Answer 2

एक अतिरिक्त प्रक्रिया हर बार 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 
         | | | |    | | 

Answer 3

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

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

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