🖕🏼 🐢 🚊 सांता क्लॉस कार्य और व्यावहारिक रसद 👩🏻‍🏭 🧜🏼 👩🏾‍🎓

यह ज्ञात है कि केवल 5% प्रोग्रामर ही मल्टीथ्रेडेड प्रोग्रामिंग कार्यों को हल करने में सक्षम हैं। और उसी स्थान पर, कोर की संख्या में वृद्धि के साथ, यहां तक कि मोबाइल उपकरणों के लिए, कई थ्रेड्स का उपयोग करने की आवश्यकता कई बार बढ़ जाती है। हर दिन नई प्रोग्रामिंग भाषाएँ दिखाई देती हैं जो विशेष रूप से समानांतर प्रोग्रामिंग की विशिष्ट समस्याओं को हल करने के लिए डिज़ाइन की जाती हैं, और पहले से ही अच्छी तरह से ज्ञात और व्यापक रूप से उपयोग की जाने वाली विधियाँ दिखाई देती हैं जो न केवल समझ को सुविधाजनक बनाती हैं, बल्कि एक तरह के प्रोग्राम कोड की कविता के समाधान को भी कम करती हैं।

एंडी ओराम और ग्रेग विल्सन द्वारा संपादित पुस्तक "आइडियल कोड" को पढ़ते हुए , मुझे समानांतर प्रसंस्करण (अध्याय 24. पृ। 444) पर अध्याय में एक दिलचस्प काम करने का मौका मिला। इसमें लेखक, साइमन पेटन जोन्स, हास्केल में एक समाधान का हवाला देते हैं। वह यह भी दावा करता है कि Ada95 और Polyphonic C # भाषाओं के लिए Sat Klaus समस्या के समाधान हैं। मेरे पेशेवर हितों के कारण, मुझे अपने सहयोगियों के साथ ऑब्जेक्टिव-सी भाषा के लिए बहु-थ्रेडेड Apple कार्यान्वयन की संभावनाओं पर थोड़ी देर पहले चर्चा करनी पड़ी।

यह माना जाता है कि प्रोग्रामिंग अमूर्तता के स्तर पर आवश्यक है, न कि "भाषा में", लेकिन उसी सफलता के साथ कोई व्यक्ति भावनाओं में कविता की सुंदरता की तलाश कर सकता है, न कि भाषा के माध्यम से व्यक्त शब्दांश की कृपा में। कटौती के तहत, मैं उन लोगों के लिए एक गीत गाने का प्रस्ताव करता हूं, जिनके लिए भाषाई अभिव्यक्ति एक खाली वाक्यांश नहीं है, लेकिन एक माधुर्य है जो कल्पना को उत्तेजित करता है।

समस्या कथन:

"सांता समय-समय पर सोता है जब तक कि वह अपने सभी नौ बारहसिंघाओं द्वारा जागृत नहीं हो जाता है, जो कि मुफ्त चराई से, या तीन कल्पित बौने के समूह द्वारा वापस आ गए हैं, जिनमें से उनके पास केवल नौ हैं। यदि हिरण उसे जगाते हैं, तो वह उनमें से प्रत्येक को स्लेज पर ले जाता है, उनके साथ खिलौने देता है, और अंत में उन्हें परेशान करता है (उन्हें मुफ्त चराई के लिए जाने देता है)। यदि कल्पित बौने उसे जगाते हैं, तो वह प्रत्येक समूह को अपने कार्यालय में ले जाता है, नए खिलौनों के विकास के बारे में उनसे बात करता है, और अंत में उनमें से प्रत्येक को कार्यालय से बाहर ले जाता है (उसे काम पर लौटने का अवसर देता है)। यदि कल्पित बौने का समूह और हिरणों का एक समूह सांता क्लॉज की प्रतीक्षा करने के लिए एक ही समय में इंतजार करता है, तो वह हिरण को प्राथमिकता देगा। " (सी)

प्रविष्टि:

मुझे यह प्रतीत हुआ कि यह भाषा की क्षमताओं का सटीक प्रदर्शन करने के लिए एक आदर्श कार्य है। एक समय में, मेरे पास C # में बहुत से मल्टीथ्रेडेड प्रोग्रामिंग थे, और फिर मैंने सोचा कि इस उद्देश्य के लिए कोई बेहतर भाषा नहीं थी। सी # अपनी सादगी और दक्षता के साथ रिश्वत दी। लेकिन Apple ने इस प्रक्रिया को एक गीत में बदल दिया। और कैसे प्रत्येक गीत में आपको उस लय, उस मीटर को महसूस करने की आवश्यकता है, जो आपके द्वारा सुनाई गई संगीत से खुशी देगा। सबसे पहले, कोष्ठक के ढेर से निपटने के लिए एक गैर-तुच्छ कार्य है, जिसे विकसित दृढ़ता और सावधानी के साथ लोगों के लिए डिज़ाइन किया गया है।

कार्य के बारे में तर्क देते हुए, इस निष्कर्ष पर आना आसान है कि एल्वेस और हिरण के बीच बहुत अंतर नहीं है। हमारे बयान में, इन दोनों जैविक रूपों को एक सार व्यक्ति के साथ बराबर किया जा सकता है जो किसी प्रकार की कार्रवाई कर सकता है जिसे बाहर से बहुत कम समझा जाता है। इसके अनुसार, यह भी महत्वपूर्ण नहीं है कि यह किस प्रकार की कार्रवाई है, लेकिन, प्रारंभिक स्थितियों के आधार पर, हिरण चरने और कल्पित बौने काम करते हैं। और तो और, उन्हें अपने व्यक्तिगत कार्यों को पूरा करने में कुछ समय लगता है। इसके अलावा, प्रत्येक व्यक्ति कार्रवाई के लिए इस कीमती संसाधन की एक अलग राशि खर्च करता है।

Xcode 4.3 में ARC का उपयोग करके सभी कोड लिखे गए हैं। यह शोधन आवश्यक है, सबसे पहले, Xcode 4.3। मैंने विधियों को देखना सीख लिया, भले ही उनके उपयोग के बाद उनका वर्णन किया गया हो, और दूसरी बात, एआरसी आपको वस्तुओं को नष्ट करने और विशेष स्मृति प्रेषण के बारे में चिंता नहीं करने की अनुमति देता है। यानी वस्तुओं को न केवल मुक्त करने की आवश्यकता नहीं है, यह बस संकलक द्वारा निषिद्ध है। लाभ महत्वपूर्ण है - कोड की पारदर्शिता में, और निष्पादन की गति में, और निश्चित रूप से, डिबगिंग पर खर्च किए गए समय में।

सबसे पहले, हम संबंधित इंटरफेस का वर्णन करते हैं:

@interface Persone : NSObject { NSInteger number; } @property (nonatomic, copy) NSString *name; //   . - (Persone *)execution; @end #import "Common.h" @interface Elf : Persone @end #import "Common.h" @interface Deer : Persone @end

जैसा कि हम देखते हैं। सब कुछ बेहद सरल है और कोई अतिरिक्त प्रश्न नहीं उठाता है।

सांता का इंटरफ़ेस अधिक दिलचस्प है।

 #import "Common.h" @interface Santa : Persone @property (nonatomic) BOOL isBusy; //  ?  \ . - (Persone *)wakeUp:(NSArray *)group; //. , .    . . ! @end

समस्या की स्थिति से, दो प्रकार के समूहों में से एक सांता को जगा सकता है। लेकिन, आश्चर्य हो सकता है। उदाहरण के लिए, सांता उस समय नहीं सो सकता है जब समूह को इकट्ठा किया जाता है, और तदनुसार, बॉस को परेशान किया जा सकता है या नहीं, इसकी समझ की आवश्यकता होती है।

प्रत्येक इंटरफेस में एक रहस्यमय फ़ाइल होती है, जो घबराहट का कारण बन सकती है:

#import "Common.h" लेकिन इसके साथ सब कुछ सरल है - यह कार्यक्रम में उपयोग किए जाने वाले स्थिरांक का अर्थ बताता है, साथ ही कुछ अन्य हेडर फाइलें भी:

 #import "Persone.h" #import "Deer.h" #import "Elf.h" #import "Santa.h" #import "Groups.h" #define kAllMessages 1 //    ,      . #define kGroupDeers @"Deer" //    . #define kGroupElfs @"Elf" //    . #define kMontsDeer 12 //      1-12. #define kMontsElf 18 //     . 1-18. #define kMontsSanta 4 //    . #define countElfInGroup 3 //     ,    . #define countDeerInGroup 9 //     ,    .

अंतिम महत्वपूर्ण इंटरफ़ेस रहता है, जो समूहों में एक ही प्रकार के व्यक्तियों की जानकारी के लिए है:

 #import "Common.h" @interface Groups : NSObject { NSMutableDictionary *groups; //  . } - (Groups *)add:(Persone *)persone; //     . - (NSArray *)ready; //   . @end

कार्यान्वयन:

यह स्पष्ट है कि हमारी समस्या को हल करने के लिए एक और केवल एक सांता की आवश्यकता है, एक और समूह बनाने के लिए केवल एक तंत्र, और हिरण और कल्पित बौने के उदाहरणों की एक मनमानी संख्या।

चलो एक सरल से शुरू करते हैं ... सबसे पहले, एक हिरण बनाएं।

 #import "Common.h" @implementation Deer static int count; @synthesize name; - (id)init { if(count >=9) return nil; //      9. self = [super init]; if (self) { count++; number = count; self.name = kGroupDeers; } return self; }

इनिशियलाइज़र काफी रूढ़िबद्ध है और किसी भी स्पष्टीकरण की आवश्यकता नहीं है। सुपरक्लास के पास नाम संपत्ति है, जिसे हम बाद में उपयोग करेंगे, शब्दकोश के लिए मुख्य मूल्य वाले चर के रूप में।

 - (void)eat { dispatch_async(dispatch_get_global_queue(0, 0), ^{ NSInteger month = (arc4random() % kMontsDeer) + 1; #if kAllMessages NSLog(@"%d-      %d ", number, month); #endif [NSThread sleepForTimeInterval:month]; #if kAllMessages NSLog(@"%d-    ", number); #endif dispatch_async(dispatch_get_main_queue(), ^{ [[[Groups alloc] init] add:self]; }); }); }

और यहाँ यह अधिक दिलचस्प है। खाने की विधि निष्पादन का एक अलग धागा शुरू करती है, हिरण की वर्तमान आवृत्ति के लिए। यही है, प्रत्येक हिरण, और भविष्य में, कल्पित बौने, अलग-अलग धाराओं में हमारे साथ रहेंगे और रहेंगे। जटिल ब्रैकेट संरचना के बावजूद, वास्तविकता में, सब कुछ बेहद सरल है: dispatch_async (dispatch_get_global_queue (0, 0), ^ {}); - निष्पादन कतार में कोष्ठक में वर्णित क्या कहते हैं। Dispatch_get_global_queue तर्क का अर्थ वैश्विक कतार है। (0, 0) - पहले 0 डिफ़ॉल्ट रूप से प्राथमिकता को इंगित करता है, सामान्य रूप से, दूसरा 0 आईओएस एसडीके में कुछ भी मतलब नहीं है, और प्रौद्योगिकी के आगे के विकास के लिए आरक्षित है।

वर्णित ब्लॉक के अंदर हम पाते हैं: NSInteger month = (arc4random ()% kMontsDeer) + 1; - हिरण चरने के महीनों की एक यादृच्छिक संख्या प्राप्त करना। इस सूत्र में प्राप्त पूर्णांकों की सीमा 1 से kMontsDeer है। इसके बाद प्रक्रिया के निष्पादन में देरी होती है - एक प्रकार का चारागाह - [NSThread sleepForTimeInterval: month]; और इस विधि को पूरा करना, एक समान कतार में जोड़ना लेकिन पहले से ही कुछ कोड के मुख्य धागे के लिए। यह कुछ कोड दूसरी कतार का प्रतिनिधित्व करता है, लेकिन पहले से ही वर्तमान कार्यक्रम के स्तर पर बनाया गया है। जैसा कि हम याद करते हैं, समूह प्रबंधक के पास पूरे आवेदन के लिए एक और एक ही होना चाहिए। दूसरे शब्दों में, वह एक गायक है। इसलिए, इनिशियलाइज़र के माध्यम से इसका उदाहरण बनाना, वास्तव में, एक मौजूदा उदाहरण में वापस आएगा, अगर यह पहले किसी द्वारा बनाया गया था। जोड़ने की विधि बस वर्तमान हिरण को प्राप्त कतार में जोड़ देगी।

 - (Persone *)execution { [self eat]; return self; } @end

उत्तरार्द्ध विधि केवल यह सुनिश्चित करती है कि अंतर्निहित इंटरफेस सुसंगत हैं। यानी एक टेम्पलेट निष्पादित विधि बनाता है।

एक समान तरीके से, हम कल्पित बौने के लिए एक वर्ग बनाते हैं।

 #import "Common.h" @implementation Elf static int count; @synthesize name; - (id)init { if(count >=10) return nil; //      10. self = [super init]; if (self) { count++; number = count; self.name = kGroupElfs; } return self; } - (void)work { dispatch_async(dispatch_get_global_queue(0, 0), ^{ NSInteger month = (arc4random() % kMontsElf) + 1; #if kAllMessages NSLog(@"   %d .   %d ", number, month); #endif [NSThread sleepForTimeInterval:month]; #if kAllMessages NSLog(@"  %d ", number); #endif dispatch_async(dispatch_get_main_queue(), ^{ [[[Groups alloc] init] add:self]; }); }); } - (Persone *)execution { [self work]; return self; } @end

बांटो और प्यार करो

समूह वर्ग का कार्य समूहों को प्रेषण और बनाना है। तंत्र काफी सरल है। प्रत्येक व्यक्ति को अपने प्रकार के लिए एक कतार में रखा जाता है, (जैसे कि कल्पित बौने, हिरण को हिरण), और फिर, यदि आवश्यक संख्या में प्रतियां कतार में एकत्र की जाती हैं, तो उन्हें वहां से हटा दिया जाता है और उनके लिए डिज़ाइन किए गए बफर में रखा जाता है - सांता का प्रतीक्षालय -Klausa।

 #import "Common.h" @implementation Groups static Groups *instance; - (id)init { if(instance!=nil) return instance; self = [super init]; if (self) { groups = [NSMutableDictionary dictionary]; instance = self; } return self; } - (Groups *)add:(Persone *)persone { NSMutableArray *queue = [groups objectForKey:persone.name]; //     . if(queue == nil) queue = [NSMutableArray array]; [queue addObject:persone]; //    . [groups setValue:queue forKey:persone.name]; #if kAllMessages NSLog(@"  \"%@\"  %d", persone.name, queue.count); #endif Santa *santa = [[Santa alloc] init]; if(santa.isBusy == NO) [santa wakeUp:[self ready]]; return self; } - (NSArray *)queueElf { NSMutableArray *queue = [groups objectForKey:kGroupElfs]; if(queue.count < countElfInGroup) return nil; //     . NSMutableArray *group = [NSMutableArray array]; for (int i=0; i<countElfInGroup; i++) // 3    ... [group addObject:[queue objectAtIndex:i]]; for (id item in group) // ...    . [queue removeObject:item]; [groups setValue:queue forKey:kGroupElfs]; return [group copy]; } - (NSArray *)queueDeer { NSMutableArray *queue = [groups objectForKey:kGroupDeers]; if(queue.count < countDeerInGroup) return nil; //     . NSArray *group = [queue copy]; for (id item in group) //   . [queue removeObject:item]; [groups setValue:queue forKey:kGroupDeers]; return group; } - (NSArray *)ready { NSArray *group = [self queueElf]; if(group!=nil) return group; return [self queueDeer]; }

जैसा कि पहले उल्लेख किया गया है, यह वर्ग एक एकल है। एआरसी का उपयोग करते हुए लिखा जा रहा है, इसका निर्माण बेहद सरल लगता है। यह माना जाता है कि इस वर्ग का एक उदाहरण मुख्य धागे के भीतर ही उपयोग किया जाएगा। यह समस्या को तब रोकेगा जब शब्दकोश के एक ही उदाहरण को अलग-अलग थ्रेड्स से लागू करने वाली कतार तक पहुँचा जा सके। बेशक, यह कुछ रनटाइम ओवरहेड बनाता है, लेकिन वे इतने अयोग्य हैं कि उन्हें उपेक्षित किया जा सकता है।

इस कोड का सबसे दिलचस्प स्थान निम्नलिखित अनुभाग है:

 Santa *santa = [[Santa alloc] init]; if(santa.isBusy == NO) [santa wakeUp:[self ready]];

हम, समूह के डिस्पैचर की तरह, हमारे सांता की एक प्रति प्राप्त करते हैं, और फिर हम वहां होंगे, गठित समूह को अपने कक्षों में भर देंगे। वैसे भी, क्या। उसके लिए, यह हिरण या कल्पित बौने होंगे, विधि उत्तर देती है - (NSArray *) तैयार

मेरे आतंक के लिए, मैंने देखा कि लेख की तैयारी के दौरान मैंने समस्या की स्थितियों को मिलाया। यानी मेरे मामले में, क्रिस्तिस पैरिबस, सांता एल्बों की सेवा करता है, हिरणों की नहीं। इसके अलावा, मेरे पास अधिकतम संख्या में कल्पित बौने हैं जो 10 के बराबर हैं, न कि 9. ये दोनों त्रुटियां आसानी से तय की जा सकती हैं। उदाहरण के लिए, विधि निम्नलिखित में बदलती है:

 - (NSArray *)ready { NSArray *group = [self queueDeer]; if(group!=nil) return group; return [self queueElf]; }

हालांकि, भविष्य में, जब यह कार्य प्रोटोकॉल की बात आती है, तो ऐसी संशोधित स्थिति यहां मान ली जाती है।

Madrigal

और इसलिए हमें अपने गीत के अंतिम चरित्र के लिए मिला - सांता:

 #import "Common.h" @implementation Santa static Santa *santa; static int count; BOOL doWork; @synthesize isBusy; static int groupNumber; - (id)init { if(santa!=nil) return santa; self = [super init]; if (self) { santa = self; count++; number = count; NSLog(@">>  %d- ", number); } return self; } - (void)sleep { NSLog(@">>  %d ....", number); } - (Santa *)wakeUp:(NSArray *)group { if(group == nil) return self; NSLog(@">>  %d .... ", number); [self work:group]; //    . return self; } - (BOOL)isBusy { return doWork; } - (void)work:(NSArray *)group { if(doWork == YES) return; doWork = YES; __block Santa *santa = self; __block NSArray *currentGroup = group; __block NSInteger IDGroup = ++groupNumber; dispatch_async(dispatch_get_global_queue(0, 0), ^{ NSInteger month = (arc4random() % kMontsSanta) + 1; NSLog(@">>    %d- .   %d  c  ID %d", number, month, IDGroup); [santa portalIn:currentGroup]; [NSThread sleepForTimeInterval:month]; NSLog(@">>  %d   c  ID %d", number, IDGroup); dispatch_async(dispatch_get_main_queue(), ^{ doWork = NO; [[santa portalOut:currentGroup] sleep]; //     . }); }); } - (Persone *)execution { NSLog(@"Yahoo!!!"); return self; } - (Santa *)portalIn:(NSArray *)group { if([[group objectAtIndex:0] isKindOfClass:[Elf class]]) NSLog(@">>  %d    ", number); if([[group objectAtIndex:0] isKindOfClass:[Deer class]]) NSLog(@"\n\t\t      yp p\n\t\t  p p  y p.\n\t\t y,  p  p p,\n\t\t y  p,    p"); return self; } - (Santa *)portalOut:(NSArray *)group { for (Persone *persone in group) [persone execution]; return self; }

कोड के सबसे जटिल भाग पर जाने से पहले, हमें दो तरीकों पर संक्षेप में ध्यान देना चाहिए:

प्रवेश द्वार विधि:

 portalIn:(NSArray *)group

और निकास द्वार विधि:

 portalOut:(NSArray *)group.

यह उनके बिना आसानी से करना संभव होगा, लेकिन वह कार्य की प्रारंभिक स्थिति थी - प्रवेश और निकास द्वार पर ध्यान केंद्रित करना।

निष्पादन विधि केवल संकेत देती है कि सांता के इस उदाहरण के लिए एक अपील थी। जब भी हम सांता के साथ छेड़छाड़ करते हैं, हम उसका नंबर दिखाते हैं। हम ऐसा कारणों से करते हैं, ताकि पाठक आश्वस्त हो जाए कि कार्रवाई के पूरे काल में एक ही सांता के साथ सभी क्रियाएं होती हैं।

विधि

  wakeUp:(NSArray *)group

समूह को प्रतीक्षालय और सांता को जागने देता है। सभी मुख्य कार्य कार्य विधि में होते हैं।

पहले हम जांचते हैं कि सांता व्यस्त है या नहीं।

 if(doWork == YES) return;

यह एक निरर्थक जाँच है और इसे हटाया जा सकता है। लेकिन, इससे बेहतर होता है कि हम कुछ गलत होने से पहले एक बार चूक जाते हैं। तब हम एक "व्यस्त" संकेत डालते हैं और सामने के दरवाजों को बंद करते हैं:

 doWork = YES;

इसके बाद, हमें थ्रेड्स, बैकग्राउंड और मुख्य के अंदर उपयोग के लिए कुछ चर तैयार करने होंगे।

 __block Santa *santa = self; __block NSArray *currentGroup = group; __block NSInteger IDGroup = ++groupNumber;

यदि ऐसा नहीं किया जाता है, तो गैर-साझा संसाधनों तक पहुंच का बहिष्करण हो सकता है। उपरोक्त सरल हेरफेर सुनिश्चित करता है कि ऐसा नहीं होता है। यहां यह ध्यान दिया जाना चाहिए कि __block कीवर्ड डबल अंडरस्कोर का उपयोग करता है। यानी _ चरित्र का उपयोग दो बार किया जाता है! फिर हम सांता के लिए एक अलग स्ट्रीम बनाते हैं, जैसा कि हमने डीयर और एल्वेस के साथ किया था, और प्रवेश द्वार विधि का उपयोग करके सांता के कक्षों में आने वाले समूह को जारी करते हैं: [santa portalIn: currentGroup];

सांता के पास कौन आया था, इसके आधार पर, वह दो चीजों में से एक करता है - या तो एक योजना बैठक आयोजित करता है या उपहार बचाता है। जब काम पूरा हो जाता है, सांता दरवाजा खोल देता है, और मेहमानों को उनके पिछले काम के स्थान पर ले जाता है। कार्य का सारा जादू निकास द्वार विधि में निहित है। जैसा कि आप जानते हैं, "पुनरावृत्ति मनुष्य के लिए अजीब है, पुनरावृत्ति दिव्य है।" - एल। पीटर। चूंकि इस पद्धति को मुख्य धागे के हिस्से के रूप में कहा जाता है, यह किसी व्यक्ति को नए कार्य को पूरा करने के लिए सुरक्षित रूप से पुन: उत्पन्न कर सकता है। एक योगिनी या हिरण, एक बार पैदा होने पर, अनिश्चित काल तक अपने कर्तव्यों का पालन करेगा, जब तक कि उन्हें SIGABRT के सिर से सीधे गोली न मार दी जाए।

और अब गाने का समय आ गया है।

एक सुविधाजनक जगह में आपको हमारे लोगों को बनाने के लिए कोड रखने की आवश्यकता है। मेरे पास इसमें स्थित है - (शून्य) दृश्यडायलाड

श्लोक १।

  for (int i = 0; i<9; i++) [[[Deer alloc] init] execution]; for (int i = 0; i<10; i++) [[[Elf alloc] init] execution]; for (int i = 0; i<4; i++) [[[Santa alloc] init] execution];

लेकिन चूंकि हमने पहले ही कुत्ते को धागा निर्माण पर खाया था, इसलिए इसे एक अलग धागे में क्यों नहीं लपेटा गया?

श्लोक २।

  dispatch_async(dispatch_get_global_queue(0, 0), ^{ for (int i = 0; i<9; i++) [[[Deer alloc] init] execution]; for (int i = 0; i<10; i++) [[[Elf alloc] init] execution]; for (int i = 0; i<4; i++) [[[Santa alloc] init] execution]; });

यह बिल्कुल स्पष्ट है कि चूंकि प्रत्येक व्यक्ति एक अलग धारा में रहता है, इसलिए प्रत्येक व्यक्ति के निर्माण का क्रम केवल संयोग से निर्धारित होगा। क्या करें? विशेष रूप से इसके लिए, धागे बनाने के अनुक्रम को इंगित करने का एक बहुत ही सुंदर तरीका है:

श्लोक ३।

 dispatch_async(dispatch_get_global_queue(0, 0), ^{ dispatch_group_t group = dispatch_group_create(); dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{for (int i = 0; i<30; i++) [[[Deer alloc] init] execution];}); dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{for (int i = 0; i<30; i++) [[[Elf alloc] init] execution];}); dispatch_group_notify(group, dispatch_get_global_queue(0, 0), ^{for (int i = 0; i<10; i++) [[[Santa alloc] init] execution];}); });

पहले बैकग्राउंड थ्रेड में, एक समूह बनाया जाता है जिसके भीतर हिरण और कल्पित बौने का निर्माण शुरू होता है। और उनके पूरा होने पर, सांता बनाने के लिए एक धागा लॉन्च किया जाता है।

अगर पहले मामलों में प्रोटोकॉल कुछ इस तरह होगा:

>> 1-
1- 6
2- 7
3- 9
4- 4
5- 3
Yahoo!!!
7- 5
9- 2
Yahoo!!!
Yahoo!!!
Yahoo!!!
6- 8
3 . 15
5 . 17
4 . 10
2 . 16
8- 3

फिर बाद के मामले में यह कुछ इस तरह होगा:

1- 7
4- 5
3- 12
2- 7
5- 3
6- 4
7- 7
8- 11
9- 6
1 . 11
2 . 2
3 . 16
4 . 4
5 . 16
6 . 1
7 . 2
8 . 14
9 . 15
10 . 3
>> 1-
Yahoo!!!
Yahoo!!!
Yahoo!!!
Yahoo!!!
Yahoo!!!
Yahoo!!!
Yahoo!!!
Yahoo!!!
Yahoo!!!
Yahoo!!!
6
"Elf" 1
2
"Elf" 2

इस एप्लिकेशन के लॉग का अध्ययन करना एक दिलचस्प काम है। लेकिन जब से वे असीम रूप से लंबे होते हैं, मैं केवल उन लोगों के लिए लिंक प्रदान करूंगा जो अभी भी कार्यों के अनुक्रम में तल्लीन करना चाहते हैं, या समस्या को हल करने के लिए अपने स्वयं के अधिक इष्टतम तरीके की पेशकश करते हैं। नीचे मैं एप्लिकेशन के स्रोत कोड का लिंक भी प्रदान करता हूं ।

लॉग में क्या दिलचस्प हो सकता है? तथ्य यह है कि प्रारंभिक स्थिरांक का अलग मूल्य पूरी तरह से अलग चरित्र व्यवहार प्रदान करता है। उदाहरण के लिए, शुरुआती डिबगिंग के दौरान, मैंने पाया कि सांता उपहार देना शुरू नहीं कर सकता है, क्योंकि वह लगातार बैठकों की दिनचर्या में व्यस्त रहेगा। कोड में एक त्रुटि के लिए एक लंबी और असफल खोज के बाद, यह पाया गया कि मानक सांख्यिकीय मॉडल के ढांचे के भीतर सब कुछ फिट बैठता है: यदि एल्फ का कार्य निष्पादन समय बहुत कम (3-4) महीने है, तो समूह इतनी बार बनेंगे कि हमेशा के लिए इंतजार करेंगे; कतारें (मुझे याद है कि समस्या को स्थिति के विलोम से हल किया गया था)।

इस अभ्यास का तार्किक मूल्य क्या है? मान लीजिए कि आप एक स्क्रैम प्रोजेक्ट मैनेजर हैं। चूंकि आपको दैनिक आधार पर बैठकें आयोजित करनी होती हैं, कभी-कभी यूएसएसआर के सुप्रीम सोवियत की पूर्ण बैठकों में गुजरते हुए, ऐसा हो सकता है कि एल्वेस के पास विकास के लिए समय नहीं है, और परियोजना एक निरंतर समय दबाव चरण में चली जाती है। टीम लीडर - सर्वर डेवलपर्स - क्लाइंट डेवलपर्स त्रिकोण में एक समान स्थिति हो सकती है, एकमात्र अंतर यह है कि टीम लीडर आमतौर पर अपनी तत्काल जिम्मेदारियों (नींद);) को पूरा करना बंद कर देता है, और रेनडियर या दुर्भावनापूर्ण के लिए कोड रेक करने के लिए मजबूर होता है; कल्पित बौने। और यदि आप आईटी क्षेत्र से दूर हो जाते हैं, तो सांता टास्क गुणांकों को माल की लोडिंग / अनलोडिंग / वेयरहाउसिंग की प्रक्रियाओं में मौलिक है। सामान्य तौर पर, वास्तविक जीवन में एनालॉग ढूंढना काफी आसान है।

निष्कर्ष:

उपरोक्त कोड में, कुछ स्पष्ट चालें नहीं हैं जिन्हें अलग से कहने की आवश्यकता है।

1)

 NSMutableArray *group = [NSMutableArray array]; [skip] return [group copy];

प्रोग्रामर जो अभी भी एआरसी के बिना काम करते हैं, वे इस कोड से भयभीत होंगे। और, सबसे अधिक संभावना है, वे कुछ का उपयोग करेंगे जैसे [[NSArray arrayWithArray: group] autorelise]; न्यूनतम कार्यक्षमता के लिए वस्तु को संक्षिप्त करना। हालांकि, एआरसी इस आवश्यकता को समाप्त कर देता है, और कोड अधिक पारदर्शी हो जाता है।

2)

 - (Santa *)portalOut:(NSArray *)group { [skip] return self; }

वर्तमान ऑब्जेक्ट को वापस करने की विधि आपको लिस्टिंग को कम करने की अनुमति देती है, जो कि कूद रिकॉर्ड के उद्देश्य-सी के उपयोग के लिए धन्यवाद: [स्वयं पोर्टल: वर्तमान जीग्रुप] नींद]; कार्यात्मक भाषाओं के प्रेमियों और जो लोग एक्स्टेंसिबल C # विधियों (जो कि LINQ में सक्रिय रूप से उपयोग किए जाते हैं) को पसंद करते हैं, यह आत्मा के लिए एक बाम की तरह है ... बेशक, डिबगिंग उद्देश्यों के लिए, यह विधि कॉल को दो लाइनों में विभाजित करने के लिए समझ में आता है।

3)

 #if kAllMessages NSLog(@"   %d .   %d ", number, month); #endif

KAllMessages precompilation निर्देश Common.h फ़ाइल में समाहित है। यदि आप इसे अनसुना करते हैं, तो वर्णों द्वारा की गई सभी क्रियाएं दिखाई देंगी, जैसा कि उपरोक्त लॉग में है। डिफ़ॉल्ट रूप से, कंसोल में केवल सांता क्रियाएँ प्रदर्शित होती हैं। मैं लेख में कंसोल आउटपुट पर नहीं गया था, क्योंकि, आमतौर पर, यह पहला परिचित है जिसके साथ हम उद्देश्य-सी का अध्ययन करते समय शुरू करते हैं।

श्रेणीबद्ध अनिवार्य:

एक लेख लिखने से एक आवेदन लिखने और इसे डीबग करने की तुलना में कई गुना अधिक समय लगा। यदि आप अभी तक अतुल्यकालिक प्रबंधक का उपयोग नहीं कर रहे हैं, तो इसे लागू करने और कार्यान्वयन की आसानी का मूल्यांकन करने का समय है। और हाँ, उसे मुझ पर एक पत्थर फेंकने दो, जो मानता है कि Apple बहु-थ्रेडेड अनुप्रयोगों के लिए अनुग्रह के चरम तक पहुंच के बिना इस समस्या को हल करने में सक्षम था।

संदर्भ:

आवेदन का स्रोत कोड (iOS एसडीके 5, एक्सकोड 4.3)।
थ्रेड निष्पादन समूहों के बिना आवेदन लॉग।
थ्रेड निष्पादन समूह के साथ आवेदन लॉग।
थ्रेड समूह में सांता के काम का संक्षिप्त रूप।

सारांश:

लेख उद्देश्य-सी भाषा में बहु-थ्रेडेड एप्लिकेशन बनाने के लिए तंत्र का वर्णन करता है जैसा कि आईओएस एसडीके 3+ पर लागू किया गया है। रसद के क्षेत्र में सांता के कार्य को एक उदाहरण के रूप में उद्धृत किया गया था। स्रोत कोड एसिंक्रोनस डिस्पैचर का उपयोग करके प्रदर्शित करता है

 dispatch_async,

आवेदन धागा कतारों

 dispatch_get_main_queue()

आवेदन पृष्ठभूमि धागा

  dispatch_get_global_queue

, और देरी अंतराल

  [NSThread sleepForTimeInterval:month];

। रैखिक सरणियों और उद्देश्य-सी द्वारा प्रदान किए गए गतिशील शब्दकोश का उपयोग अतिरिक्त कतार बनाने के लिए किया गया था।

UPD: सोर्स कोड का लिंक अपडेट किया।

सांता क्लॉस कार्य और व्यावहारिक रसद