डी प्रोग्रामिंग - कंसीडर

Concurrency एक समय में कई थ्रेड्स पर चलने वाला प्रोग्राम बना रहा है। समवर्ती कार्यक्रम का एक उदाहरण एक वेब सर्वर है जो एक ही समय में कई ग्राहकों को जवाब देता है। संदेश भेजने के साथ सम्‍मिलितता आसान है, लेकिन यदि वे डेटा साझाकरण पर आधारित हैं तो लिखना बहुत कठिन है।

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

डी में थ्रेडिंग शुरू करना

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

उदाहरण

import std.stdio; 
import std.stdio; 
import std.concurrency; 
import core.thread;
  
void worker(int a) { 
   foreach (i; 0 .. 4) { 
      Thread.sleep(1); 
      writeln("Worker Thread ",a + i); 
   } 
}

void main() { 
   foreach (i; 1 .. 4) { 
      Thread.sleep(2); 
      writeln("Main Thread ",i); 
      spawn(≈worker, i * 5); 
   }
   
   writeln("main is done.");  
}

जब उपरोक्त कोड संकलित और निष्पादित किया जाता है, तो यह पिछले अनुभाग में बनाई गई फ़ाइल को पढ़ता है और निम्नलिखित परिणाम उत्पन्न करता है -

Main Thread 1 
Worker Thread 5 
Main Thread 2 
Worker Thread 6 
Worker Thread 10 
Main Thread 3 
main is done. 
Worker Thread 7 
Worker Thread 11 
Worker Thread 15 
Worker Thread 8 
Worker Thread 12 
Worker Thread 16 
Worker Thread 13
Worker Thread 17 
Worker Thread 18

D में थ्रेड आइडेंटिफायर

मॉड्यूल स्तर पर वैश्विक स्तर पर उपलब्ध यह Tid वैरिएबल हमेशा वर्तमान थ्रेड की आईडी है। इसके अलावा, आप थ्रेड प्राप्त कर सकते हैं जब स्पॉन कहा जाता है। एक उदाहरण नीचे दिया गया है।

उदाहरण

import std.stdio; 
import std.concurrency;  

void printTid(string tag) { 
   writefln("%s: %s, address: %s", tag, thisTid, &thisTid); 
} 
 
void worker() { 
   printTid("Worker"); 
}
  
void main() { 
   Tid myWorker = spawn(&worker); 
   
   printTid("Owner "); 
   
   writeln(myWorker); 
}

जब उपरोक्त कोड संकलित और निष्पादित किया जाता है, तो यह पिछले अनुभाग में बनाई गई फ़ाइल को पढ़ता है और निम्नलिखित परिणाम उत्पन्न करता है -

Owner : Tid(std.concurrency.MessageBox), address: 10C71A59C 
Worker: Tid(std.concurrency.MessageBox), address: 10C71A59C 
Tid(std.concurrency.MessageBox)

संदेश पासिंग डी में

फ़ंक्शन भेजने () संदेश भेजता है और फ़ंक्शन प्राप्त करता है () एक विशेष प्रकार के संदेश के लिए प्रतीक्षा करता है। प्राथमिकताएं (), प्राप्त (), और प्राप्त करने वाले नाम () नाम के अन्य कार्य हैं, जिन्हें बाद में समझाया गया है।

निम्नलिखित कार्यक्रम में मालिक अपने कार्यकर्ता को टाइप का संदेश भेजता है और टाइप डबल के कार्यकर्ता से संदेश का इंतजार करता है। धागे तब तक संदेश भेजना जारी रखते हैं जब तक कि मालिक एक नकारात्मक इंट नहीं भेजता। एक उदाहरण नीचे दिया गया है।

उदाहरण

import std.stdio; 
import std.concurrency; 
import core.thread; 
import std.conv;  

void workerFunc(Tid tid) { 
   int value = 0;  
   while (value >= 0) { 
      value = receiveOnly!int(); 
      auto result = to!double(value) * 5; tid.send(result);
   }
} 
 
void main() { 
   Tid worker = spawn(&workerFunc,thisTid); 
    
   foreach (value; 5 .. 10) { 
      worker.send(value); 
      auto result = receiveOnly!double(); 
      writefln("sent: %s, received: %s", value, result); 
   }
   
   worker.send(-1); 
}

जब उपरोक्त कोड संकलित और निष्पादित किया जाता है, तो यह पिछले अनुभाग में बनाई गई फ़ाइल को पढ़ता है और निम्नलिखित परिणाम उत्पन्न करता है -

sent: 5, received: 25 
sent: 6, received: 30 
sent: 7, received: 35 
sent: 8, received: 40 
sent: 9, received: 45

वाट्स इन डी के साथ संदेश पासिंग

प्रतीक्षा के साथ गुजरने वाले संदेश के साथ एक सरल उदाहरण नीचे दिखाया गया है।

import std.stdio; 
import std.concurrency; 
import core.thread; 
import std.conv; 
 
void workerFunc(Tid tid) { 
   Thread.sleep(dur!("msecs")( 500 ),); 
   tid.send("hello"); 
}
  
void main() { 
   spawn(&workerFunc,thisTid);  
   writeln("Waiting for a message");  
   bool received = false;
   
   while (!received) { 
      received = receiveTimeout(dur!("msecs")( 100 ), (string message) { 
         writeln("received: ", message); 
      });

      if (!received) { 
         writeln("... no message yet"); 
      }
   } 
}

जब उपरोक्त कोड संकलित और निष्पादित किया जाता है, तो यह पिछले अनुभाग में बनाई गई फ़ाइल को पढ़ता है और निम्नलिखित परिणाम उत्पन्न करता है -

Waiting for a message 
... no message yet 
... no message yet 
... no message yet 
... no message yet 
received: hello