🚇 👨‍🍳 🦖 C # में डेटा को संसाधित करते समय समानांतरकरण का उपयोग करना 🌳 🎙️ 🧑🏼‍🤝‍🧑🏻

सबके लिए दिन अच्छा हो! मैं आंतरिक ऑडिट प्रणाली में काम करने वाला तकनीकी विशेषज्ञ हूं, मेरी जिम्मेदारियों में C # प्रोग्रामिंग भाषा में ETL टूल बनाना शामिल है।

समय-समय पर, डेटा स्रोत कसकर संरचित फाइलें xml, csv, json, या किसी अन्य प्रारूप में होती हैं। कभी-कभी उनकी संख्या काफी बड़ी हो जाती है और लगातार बढ़ती जा रही है। उदाहरण के लिए, मेरे एक कार्य में, प्रतिदिन लगभग 150,000 फ़ाइलों की औसत ताज़ा दर के साथ फाइलों की संख्या में वृद्धि हुई। यदि एक ही समय में एक फ़ाइल को संसाधित करना (हार्ड डिस्क से बाइट्स की एक सरणी को मेमोरी में पढ़ना, डाउनलोड किए गए डेटा को बदलना और उन्हें डेटाबेस में लिखना) एक सेकंड लेता है, तो यह स्पष्ट हो जाता है कि सभी फ़ाइलों को संसाधित करने में 40 घंटे से अधिक समय लगेगा। इस मामले में, हम इन फ़ाइलों को अंत तक संसाधित नहीं कर पाएंगे, क्योंकि फ़ाइलों की संख्या बढ़ने की गति उनके प्रसंस्करण की गति से स्पष्ट रूप से अधिक होगी।

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

इन कठिनाइयों से बचने के लिए, Microsoft ने TPL लाइब्रेरी को .Net फ्रेमवर्क (संस्करण 4.0 से शुरू) में जोड़ा। मैं आपको बताऊंगा कि इस समस्या को हल करने के लिए इस पुस्तकालय का उपयोग कैसे करें।

इसलिए, शुरू में ऑपरेशन एल्गोरिथ्म निम्नानुसार दिखता है: एक

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

जाहिर है, सबसे अधिक समय लेने वाला संचालन हार्ड डिस्क से मेमोरी में डेटा पढ़ रहा है और मेमोरी से डेटाबेस तक डेटा लिख रहा है।

आइए TPL लाइब्रेरी का उपयोग करके हमारे एल्गोरिथ्म को अनुकूलित करने का प्रयास करें:

चरण 1।

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

बिंदु 2:
एक फाइल से प्रोसेसिंग डाटा का एक चक्र बनाते हुए डिजाइन को बदलते हैं। Parallel.For या Parallel.ForEach के साथ बदलें।

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

Parallel.ForEach(listFiles, (currentFile) =>
       	  {
              	var dataFile = getDataFile(currentFile.FullName);
		TransformData(dataFile);
		WriteToDB(dataFile);
               });

जहाँ:

listFiles निर्देशिका में फ़ाइलों की एक सूची वाले समवर्ती प्रकार का एक संग्रह है;
currentFile - listFiles संग्रह का एक तत्व, जिसे फॉरएच निर्माण द्वारा लौटाया गया है;
dataFile - मेमोरी में एक सशर्त कुछ डेटा संरचना, जो फ़ाइल की सामग्री को मेमोरी में पढ़कर प्राप्त की जाती है;
getDataFile - एक सशर्त फ़ंक्शन जो कुछ डेटा संरचना के रूप में एक फ़ाइल की सामग्री लौटाता है;
ट्रांसफॉर्मडाटा - प्राप्त डेटा को बदलने के लिए सशर्त प्रक्रिया;
डेटाबेस में डेटा लिखने के लिए WriteToDB एक सशर्त प्रक्रिया है।

इस उदाहरण में, Parallel.ForEach निर्माण का उपयोग करके, हम लूप को व्यवस्थित करेंगे। इस चक्र में, समानांतर धाराओं में, डेटा को हार्ड डिस्क, उनके परिवर्तन और डेटाबेस में लिखा जाता है। इसी समय, समानांतर प्रवाह के काम को व्यवस्थित करने में कोई समस्या नहीं है। समानांतर धागे की संख्या प्रोसेसर कोर और उनके कार्यभार की संख्या पर निर्भर करती है।

प्रस्तावित एल्गोरिथ्म का उपयोग करते हुए, हम कम से कम 2 बार फ़ाइल प्रसंस्करण को गति देंगे। यद्यपि, निश्चित रूप से, यह आंकड़ा कोर की संख्या और मशीन की मेमोरी के आधार पर अलग-अलग होगा, जिस पर कार्यक्रम चलेगा।

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

डेटाबेस में लेखन के अनुकूलन को ध्यान में रखते हुए, हम उपरोक्त उदाहरण को फिर से लिखते हैं।
मान लीजिए कि एक फाइल रीडर हमें DataTable में डेटा लौटाता है):

Parallel.ForEach(listFiles, (currentFile) =>
       	  {
              	DataTable dataFile = getDataFile(currentFile.FullName);
		TransformData(dataFile);
		threadWriteToDB.ListData.Enqueue(dataFile);
               });

जैसा कि आप देख सकते हैं, डेटाबेस में लिखने की प्रक्रिया के लिए एक कॉल के साथ एक लाइन के बजाय, हम बस वर्णित समवर्ती queueData संग्रह में वर्णित हैं और एक अलग थ्रेड में इनिशियलाइज़ किए गए हैं, जिसका उदाहरण थ्रेडट्राइट टीओडीबी हमारे लूप में उपयोग किया जाता है।

डेटाबेस में लिखना पहले से ही एक अलग स्ट्रीम में है। डेटाबेस के लिए लेखन Parallel.For और / या Paral-lel.Foreach निर्माणों का उपयोग करके फ़ाइलों के साथ काम करने के लिए समान रूप से व्यवस्थित किया जा सकता है।

मेरे कार्य में, जहां एक तुलनीय संख्या में फ़ाइलों को संसाधित करना आवश्यक था, अब यह औसतन प्रति दिन 200,000 से 400,000 फ़ाइलों तक की प्रक्रिया कर सकता है, और गति डेटाबेस और डेटा चैनल की चौड़ाई को लोड करके सीमित है।

C # में डेटा को संसाधित करते समय समानांतरकरण का उपयोग करना

More articles: