लूप के लिए डी में मल्टीथ्रेडिंग

Question

मुझे पता है कि जंग हल्के धागे के साथ लूप चला सकता है। कुछ ऐसा:

use task::spawn; 

fn main() { 
    for 100.times { 
    do spawn { 
     io::println("Hello"); 
    } 
    } 

मैं डी में यह कैसे कर सकता हूं?

Answer 1

प्रासंगिक एपीआई दस्तावेज़: एक TaskPool के parallel का उपयोग कर,

समानांतर foreach: std.parallelism

यहाँ अपने उदाहरण को पूरा करने के तौर-तरीकों में से कुछ हैं

foreach (i, val; taskPool.parallel(new int[50])) { 
    writeln("Hello:", i); 
} 

नियमित foreach बताया put का उपयोग करके कार्य पूल में कार्य:

foreach (i; 0 .. 50) { 
    auto t = task!writeln("Hello:", i); 
    taskPool.put(t); 
} 

एक TaskPool के बजाय एक new thread में प्रत्येक कार्य निष्पादित करें:

foreach (i; 0 .. 50) { 
    auto t = task!writeln("Hello:", i); 
    t.executeInNewThread(); 
} 

जंग के क्रम में एक अंतर्निहित कार्य अनुसूचक है, लेकिन डी के साथ, यह किसी लाइब्रेरी के रूप में कार्यान्वित किया जाता है। कहा जा रहा है कि दूसरा कार्यक्षमता के मामले में निकटतम है, और आखिरी वाक्य वाक्यविन्यास के मामले में निकटतम है (लेकिन वे ओएस धागे हैं, हल्के वजन नहीं)।

डी में, हल्के धागे को प्रोग्रामर द्वारा स्पष्ट रूप से नियंत्रित किया जाता है। एक TaskPool जंग/गो में शेड्यूलर के समान है, लेकिन यह प्रोग्रामर को अधिक बढ़िया नियंत्रण देता है। यह थोड़ा और वर्बोज़ बनाता है, लेकिन यह आपको map, reduce, foreach इत्यादि के समानांतर संस्करण भी प्रदान करता है। इससे अधिक जटिल एल्गोरिदम का प्रभावी ढंग से प्रतिनिधित्व करना आसान हो जाता है।

प्रत्येक उदाहरण को चलाने से आपको अपेक्षित परिणाम मिलना चाहिए: ऑर्डर लिखने से बाहर।

नोट:

डॉक से:

इस पूल में कार्यकर्ता सूत्र, डेमॉन धागे हैं जिसका अर्थ है कि यह आवश्यक समाप्त होने से पहले TaskPool.stop या TaskPool.finish कॉल करने के लिए नहीं है मुख्य धागा

दूसरा उदाहरण तब तक इंतजार नहीं करता जब तक सभी श्रमिक नहीं किए जाते हैं, इसलिए परीक्षण में आपको कोई परिणाम नहीं मिल सकता है (जब मुख्य खत्म होता है, सभी शेष कार्य मारे जाते हैं)। आप finish फोन करके ब्लॉक करने के लिए आवश्यकता हो सकती है:

taskPool.finish(true); 

Answer 2

डी हल्के धागे के लिए कोई अंतर्निहित कपोल-कल्पना है।इसके बजाय, आप कर सकते हैं:

• उपयोग धागे
• उपयोग fibers (std.concurrency और std.parallelism देखें), और स्पष्ट रूप से निष्पादन
• उपज करके स्वयं भी एक से अधिक कार्य जैसे Vibe.d एक पुस्तकालय है, जो अतुल्यकालिक मैं/हे फाइबर का उपयोग लागू करता है का उपयोग करें और निहित अवरुद्ध कार्यों पर उपज