Thread creation and synchronization c++ In Hindi
C++ प्रोग्रामिंग लैंग्वेज में थ्रेड क्रिएट करना, थ्रेड सिंक्रोनाइज़ेशन का प्रॉपर मैनेजमेंट और थ्रेड-सेफ एक बेहतर C++ प्रोग्राम क्रिएट करने के लिए इम्पोर्टेन्ट कॉन्सेप्ट या फीचर्स हैं। किसी C++ प्रोग्राम में थ्रेड क्रिएट करने से C++ यूजर एक साथ मल्टीप्ल टास्क परफॉर्म कर सकते हैं. जबकि थ्रेड सिंक्रोनाइज़ेशन फीचर्स आपको यह फिक्स करने में हेल्प करता है कि मौजूदा प्रोग्राम में थ्रेड शेयर्ड रिसोर्स के साथ कंट्रोल और अनुमान के हिसाब से बेहतर यूजर इंटरैक्ट करें।
Creating Threads in C++ Programming.
किसी भी C++ प्रोग्राम में, थ्रेड क्रिएट करने और थ्रेड मैनेजमेंट को मैनेज करने के लिए std::thread क्लास (C++11 वर्जन में लांच) को यूज़ किया जाता है।
Creating a Basic Thread in C++ Programming.
C++ प्रोग्राम में एक बेसिक थ्रेड क्रिएट करने के लिए, C++ यूजर एक std::thread ऑब्जेक्ट को इंस्टैंशिएट करते हैं, और उस थ्रेड के माध्यम से एक्ज़ीक्यूट किए जाने के लिए एक यूजर डिफाइन क्लास फ़ंक्शन (या कॉलेबल ऑब्जेक्ट, जैसे लैम्ब्डा फ़ंक्शन एक्सप्रेशन) को पास करते हैं। जरूरत पड़ने पर C++ यूजर मौजूदा प्रोग्राम में थ्रेड द्वारा कॉल किए जा रहे कस्टम फ़ंक्शन पैरामीटर वैल्यू को आर्गुमेंट के रूप में में भी पास कर सकते हैं।
Example of creating a basic thread in a C++ program.
#include <iostream>
#include <thread>
void BasicThread() {
std::cout << “Vcanhelpsu create with a new thread” << std::endl;
}
int main() {
// here we create and launch a new thread
std::thread t(BasicThread);
// here we wait for the thread to finish
t.join(); // here it blocks the main thread until t finishes
return 0;
}
Explanation of creating a basic thread in a C++ program.
- यहाँ इस एक्साम्प्ल में, std::thread t(BasicThread); एक नया थ्रेड क्रिएट करता है, जो मौजूदा प्रोग्राम में एक BasicThread फ़ंक्शन को रन करेगा।
- इसमें t.join(); फंक्शन यह फिक्स करता है कि मेन थ्रेड आगे बढ़ने से पहले t के टर्मिनेट होने का वेट करता है।
Passing Arguments to Threads in C++ Programming.
C++ प्रोग्राम में यूजर डिफाइन उस फ़ंक्शन को आर्गुमेंट में पास कर सकते हैं, जिसे यूजर डिफाइन थ्रेड रन करता है. यहाँ बस आपको उन फ़ंक्शन के नाम के बाद std::thread कंस्ट्रक्टर में पास करके यूज़ करना होता है।
Example of passing arguments to a C++ thread.
#include <iostream>
#include <thread>
void countTotal(int p, int q) {
std::cout << “The total of p and q is – ” << p + q << std::endl;
}
int main() {
int m = 3;
int n = 8;
// here we pass arguments to the thread function
std::thread t(countTotal, m, n);
// here we wait for the thread to finish
t.join();
return 0;
}
Explanation of passing arguments to a C++ thread.
- यहाँ इस एक्साम्प्ल में, std::thread t(countTotal, m, n); एक थ्रेड क्रिएट करता है, जो m और n आर्गुमेंट के साथ countTotal थ्रेड फंक्शन को रन करता है।
Using lambda functions with threads in C++ programming.
किसी C++ प्रोग्राम में एक अलग फ़ंक्शन क्रिएट करने के बदले, C++ यूजर थ्रेड के साथ सीधे एक यूजर डिफाइन कस्टम लैम्ब्डा फ़ंक्शन को यूज़ कर सकते हैं। लैम्ब्डा फक्शन स्पेशली रूप से तब यूज़ किए जाते हैं, जब C++ यूजर ऐसे छोटे टास्क क्रिएट करना चाहते हैं, जिन्हें किसी प्रोग्राम में दोबारा यूज़ करने की ज़रूरत न हो।
Example of a lambda function with a thread in C++.
#include <iostream>
#include <thread>
int main() {
int p = 6;
int q = 3;
// here we create and launch a thread using a lambda function method
std::thread t([p, q]() {
std::cout << “The total of p and q is – ” << p + q << std::endl;
});
// here we wait for the thread to finish first
t.join();
return 0;
}
Explanation of a lambda function with a thread in C++.
- यहाँ इस एक्साम्प्ल में, लैम्ब्डा एक्सप्रेशन [p, q]() { … } को std::thread में पास किया जाता है, और यह आस-पास के स्कोप से p और q की वैल्यू को वैल्यू के हिसाब से कैप्चर करता है।
Joining and Detaching Threads in C++ Programming.
C++ प्रोग्रामिंग में एक नया थ्रेड क्रिएट करने के बाद, C++ यूजर को या तो उसे जॉइन करना होगा या उस थ्रेड को डिस्पैच करना होगा।
Joining and Detaching Threads in C++ Programming.
- join() – यह C++ प्रोग्राम में कॉलिंग थ्रेड (सामान्य रूप से मेन थ्रेड) को तब तक ब्लॉक करता है, जब तक कि मौजूदा प्रोग्राम में जॉइन किया जा रहा थ्रेड एग्जीक्यूट नहीं हो जाता है। यह किसी प्रोग्राम में थ्रेड ज्वाइन को चेक करने का एक तरीका है कि मेन थ्रेड आगे बढ़ने से पहले नए बनाए गए थ्रेड के पूरा होने का वेट करना है।
- detach() – यह C++ प्रोग्राम में यूजर डिफाइन थ्रेड को इंडिपेंडेंटली रन होने देता है, और प्रोग्राम में डिफाइन मेन थ्रेड उसका वेट नहीं करता है। मौजूदा प्रोग्राम में जरूरी थ्रेड को डिटैच करने के बाद, यह एक “अलग” थ्रेड बन जाता है. और इसके बाद C++ यूजर इसे और जॉइन नहीं कर सकते है।
Example of thread joining in a C++ program.
#include <iostream>
#include <thread>
void previewInfo() {
std::cout << “System define Thread is executed.” << std::endl;
}
int main() {
std::thread t(previewInfo);
// here we wait for the thread to finish first
t.join(); // here main thread will wait for t to finish then move next
return 0;
}
Explanation of thread joining in a C++ program.
- यहाँ इस एक्साम्प्ल में, t.join() यह फिक्स करता है कि मेन थ्रेड एग्ज़िक्यूशन टर्मिनेट होने के लिए t का वेट करे।
Example of thread detach in a C++ program.
#include <iostream>
#include <thread>
#include <chrono>
void testThread() {
std::this_thread::sleep_for(std::chrono::seconds(2));
std::cout << “Here Thread delayed for 2 second.” << std::endl;
}
int main() {
std::thread t(testThread);
// here we detach the thread, main thread don’t wait for it process
t.detach();
// here main thread continues execution
std::cout << “Main thread is ready to continue.” << std::endl;
std::this_thread::sleep_for(std::chrono::seconds(3)); // here it give detached thread time to finish first
return 0;
}
Explanation of thread detach in a C++ program.
- यहाँ इस एक्साम्प्ल में, t.detach() थ्रेड को अलग से रन होने देता है। जहा मेन थ्रेड इसके टर्मिनेट होने का इंतज़ार नहीं करता है, लेकिन हम प्रोग्राम को अलग किए गए थ्रेड को रन करने के लिए यह काफ़ी समय देते हैं।
- याद रहे, किसी C++ प्रोग्राम में detach() फंक्शन मेथड का यूज़ करते समय केयरफुल रहें, क्योंकि यह एक बार किसी थ्रेड से अलग हो जाने के बाद, उसे दोबारा जोड़ा या सिंक्रोनाइज़ नहीं किया जा सकता है। यदि किसी प्रोग्राम में मेन थ्रेड अलग किए गए थ्रेड से पहले टर्मिनेट होकर एग्जिट हो जाता है. तो यदि अलग किया गया थ्रेड पहले से नष्ट किए गए रिसोर्स को एक्सेस करने की कोशिश करता है. तो इससे अनडिफाइंड थ्रेड बिहेवियर डेवलप हो सकता है।
Thread Synchronization in C++ Programming
जब किसी C++ प्रोग्राम में मल्टीप्ल थ्रेड शेयर किए गए रिसोर्स को एक्सेस करते हैं, तो C++ यूजर को रेस कंडीशन और डेटा करप्शन को अवॉयड करने के लिए सही थ्रेड सिंक्रोनाइज़ेशन को फिक्स करना होगा। C++ इसके यूजर को थ्रेड को सिंक्रोनाइज़ करने के लिए कई मैकेनिज़्म प्रोवाइड करता है. जैसे म्यूटेक्स, लॉक और कंडीशन वेरिएबल आदि है।
Mutex (std::mutex)
C++ प्रोग्राम में एक म्यूटेक्स (म्यूचुअल एक्सक्लूज़न का स्माल वर्जन) का यूज़ शेयर किए गए डेटा को कई थ्रेड द्वारा एक साथ एक्सेस किए जाने से अवॉयड करने के लिए किया जाता है। थ्रेड में शेयर्ड रिसोर्स को एक्सेस करने से पहले आप म्यूटेक्स को लॉक करते हैं, और काम पूरा होने पर म्यूटेक्स को अनलॉक करते हैं।
Example of using a mutex for synchronization in C++.
#include <iostream>
#include <thread>
#include <mutex>
std::mutex mtx; // here we define mutex to protect shared thread data
void displayThread(int data) {
std::lock_guard<std::mutex> lock(mtx); // here we lock the mutex automatically
std::cout << “Thread ” << data << ” is displaying information.” << std::endl;
}
int main() {
std::thread td1(displayThread, 1);
std::thread td2(displayThread, 2);
// here we wait for both threads to finish first
td1.join();
td2.join();
return 0;
}
Explanation of using a mutex for synchronization in C++.
- यहाँ इस एक्साम्प्ल में, std::lock_guard<std::mutex> lock(mtx); यह फिक्स करता है कि मौजूदा थ्रेड स्कोप में एंटर करते समय म्यूटेक्स mtx में आटोमेटिक लॉक हो जाए, और जब इसके स्कोप से बाहर निकलने पर ऑटोमैटिकली म्यूटेक्स रिलीज़ हो जाए (जैसे, जब लॉक ऑब्जेक्ट इसके स्कोप से बाहर चला जाए)।
- यह फीचर्स आपको एक ही समय में मल्टीप्ल थ्रेड्स को std::cout पर डिस्प्ले प्रिंट होने से ब्लॉक करता है, जिससे मौजूदा प्रोग्राम में इंटरलीव्ड या गड़बड़ आउटपुट रन हो सकता है।
std::unique_lock vs. std::lock_guard in C++.
- std::lock_guard – यह C++ थ्रेड प्रोग्राम में एक आसान, RAII-स्टाइल लॉक है. जो म्यूटेक्स के क्रिएट होने पर लॉक करता है, और इसके स्कोप से बाहर हो जाने पर आटोमेटिक इसे रिलीज़ करता है।
- std::unique_lock – C++ थ्रेड प्रोग्राम में std::lock_guard से ज़्यादा फ्लेक्सिबल मेथड है। यह मैन्युअल थ्रेड ऑब्जेक्ट लॉकिंग और अनलॉकिंग का फीचर्स प्रोवाइड करता है, और इसे थ्रेड में कंडीशन वेरिएबल्स या (ज़्यादा एडवांस्ड यूज़) के साथ अप्लाई किया जा सकता है।
