सहज ज्ञान युक्त समवर्ती प्रोग्रामिंग सार के साथ आधुनिक प्रोग्रामिंग भाषा [बंद]

40

मुझे एप्लिकेशन / उपयोगकर्ता स्तर (सिस्टम प्रोग्रामिंग नहीं) पर ध्यान केंद्रित करते हुए, समवर्ती प्रोग्रामिंग सीखने में दिलचस्पी है। मैं एक आधुनिक उच्च स्तरीय प्रोग्रामिंग भाषा की तलाश में हूं जो समवर्ती अनुप्रयोगों को लिखने के लिए सहज ज्ञान युक्त सार प्रदान करता है। मैं उन भाषाओं पर ध्यान देना चाहता हूं जो उत्पादकता बढ़ाती हैं और समवर्ती प्रोग्रामिंग की जटिलता को छिपाती हैं।

कुछ उदाहरण देने के लिए, मैं C, C ++, या Java में मल्टीथ्रेडेड कोड लिखने वाले एक अच्छे विकल्प पर विचार नहीं करता क्योंकि IMHO मेरी उत्पादकता कम है और उनका प्रोग्रामिंग मॉडल सहज नहीं है। दूसरी ओर, ऐसी भाषाएँ जो उत्पादकता बढ़ाती हैं और पायथन और मल्टीप्रोसेसिंग मॉड्यूल, एर्लैंग, क्लॉजुर, स्काला, आदि जैसे अधिक सहज ज्ञान युक्त सार प्रदान करती हैं, वे अच्छे विकल्प होंगे।

आप अपने अनुभव के आधार पर क्या सलाह देंगे और क्यों?

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

— फॉफ
स्रोत

21

To give an example, I don't consider a good option writing multithreaded code in C, C++, or Java। क्यूं कर? On the other hand, Python and the multiprocessing module, Erlang, Clojure, Scala, etc. are some of my options.फिर, क्यों? अपने प्रश्न को बेहतर ढंग से परिभाषित करने के लिए विस्तृत करें कि आप वास्तव में क्या देख रहे हैं।

— यानि

2

तो क्या आप सभी गोचरों के साथ समानांतर प्रोग्रामिंग सीखना चाहते हैं या आप इसकी कुछ जटिलता को छिपाना चाहते हैं और उत्पादकता पर ध्यान केंद्रित करना चाहते हैं?

— MaR

@ एमआरआर उत्पादकता पर ध्यान केंद्रित करें और जटिलता को छुपाये :)

— sakisk

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

— user606723

1

@DeadMG कम उत्पादकता उनकी समस्या है। मैं समस्या के बजाय भाषा के वाक्य-विन्यास पर ध्यान केंद्रित नहीं करना चाहता। मैं निश्चित रूप से गतिरोध से जूझना नहीं चाहता। एक सरल उदाहरण के रूप में, मैं सरल कथनों का उपयोग करना चाहता हूं जैसे कि begin transaction end transactionऔर अंदर की सभी चीजें गतिरोध-मुक्त होनी चाहिए और या तो पूरी तरह से सफल या असफल होनी चाहिए।

— साकिस

33

आपको लगभग निश्चित रूप से क्लॉजुर को देखना चाहिए - मेरी राय में यह मल्टी-कोर प्रोग्रामिंग के लिए सबसे अच्छी आधुनिक भाषा है और यह बेहद उत्पादक है।

मुख्य विशेषताएं:

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

एक संगामित तिरछा के साथ कुछ मिनी कोड नमूने:

;; define and launch a future to execute do-something in another thread
(def a (future (do-something)))

;; wait for the future to finish and print its return value
(println @a)

;; call two functions protected in a single STM transaction
(dosync
  (function-one)
  (function-two))

विशेष रूप से, यह इनमें से एक या अधिक वीडियो देखने लायक है:

— मिकेरा
स्रोत

21

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

— मेसन व्हीलर

8

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

— मेसन व्हीलर

1

@MasonWheeler: IMHO यदि आप यह नहीं जान सकते हैं कि किसी प्रकार के एनोटेशन के बिना किसी फ़ंक्शन को कैसे कॉल किया जाए, तो यह प्रलेखन (या इसके अभाव) के साथ एक समस्या है। यहां तक कि बतख टाइप की गई भाषाओं में भी सब कुछ आमतौर पर कुछ संरचनात्मक प्रकार की बाधाओं को पूरा करना होता है (जैसे अंकगणितीय कार्यों का समर्थन करना चाहिए, पुनरावृत्त होना चाहिए, अनुक्रमित होना चाहिए, आदि)। स्टेटिक प्रकार केवल न्यूनतम मदद क्योंकि वे समारोह क्या बारे में ज्यादा संकेत नहीं देना होगा होगा करता है ।

— dsimcha

2

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

— मीका

1

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

— मीका

27

आप डी। की कोशिश कर सकते हैं। यह तीन मॉडल प्रदान करता है। मैं या तो पहले या दूसरे की सलाह देता हूं।

std.concurrency । यदि आप अपनी सभी संगणक आवश्यकताओं के लिए इस मॉड्यूल का उपयोग करते हैं, तो भाषा और मानक पुस्तकालय का एक संयोजन थ्रेड्स के बीच अलगाव को लागू करता है। थ्रेड्स मुख्य रूप से संदेश के माध्यम से संवाद करते हैं, साझा मेमोरी के लिए सीमित समर्थन के साथ "सुरक्षा पहले" का पक्ष लेते हैं और निम्न-स्तरीय डेटा रेस को रोकते हैं। दुर्भाग्य से std.concurrency के प्रलेखन में सुधार की आवश्यकता है, लेकिन मॉडल को आंद्रेई अलेक्जेंड्रेस्कु की पुस्तक "द डी प्रोग्रामिंग लैंग्वेज" के एक मुक्त अध्याय में प्रलेखित किया गया है ।
std.parallelism । इस मॉड्यूल को विशेष रूप से बहु-स्तरीय समानता के लिए डिज़ाइन किया गया है न कि सामान्य-मामले की संगति के लिए। ( समानता और समानतावाद एक ही बात नहीं है, हालांकि समतावाद को लागू करने के लिए समानता आवश्यक है। ) चूंकि समानांतरवाद का पूरा बिंदु प्रदर्शन है, std.parallelism कोई अलगाव की गारंटी नहीं देता है क्योंकि वे कुशल समानांतर कोड लिखना मुश्किल बना देंगे। हालाँकि, यह बहुत अधिक त्रुटि-स्तर वाले निम्न-स्तरीय विवरणों का सार करता है, ताकि यदि आप मैन्युअल रूप से स्वतंत्र रूप से सत्यापित हैं तो वर्कलोड को बराबर करने में बहुत मुश्किल है।
core.thread OS- विशिष्ट थ्रेडिंग API पर एक निम्न-स्तरीय आवरण है। Std.concurrency और std.parallelism दोनों इसे हुड के तहत उपयोग करते हैं, लेकिन मैं केवल इसका उपयोग करने की सलाह दूंगा यदि आप अपनी खुद की संगोष्ठी पुस्तकालय लिख रहे हैं या कुछ हास्यास्पद कोने का मामला ढूंढ सकते हैं जो कि std.parallelism या std दोनों में से कोई भी अच्छा नहीं कर सकता है .concurrency। किसी को भी दिन-प्रतिदिन के काम के लिए इस निम्न-स्तर का उपयोग नहीं करना चाहिए।

— dsimcha
स्रोत

आपको अपरिवर्तनीयता / शुद्धता, डिफ़ॉल्ट रूप से थ्रेड स्थानीय भंडारण और अनुक्रमिक क्रम में उत्परिवर्तन लगाने वाले साझा का उल्लेख करना चाहिए। Thoses ऐसी भाषाएँ हैं जो C / C ++ में अनुपलब्ध कोड लिखने के लिए गायब हैं।

— डेडलिंक

@deadalnix: मेरे लिए उनमें से अधिकांश std.concurrency मॉडल (कैसे अलगाव लागू है) का विवरण है। मैं इस पद को संक्षिप्त रखना चाहता था।

— dsimcha

खैर वास्तव में नहीं। लाइब्रेरी और लैंग्वेज सपोर्ट के लिए कॉन्सुरेंसी की जरूरत होती है।

— डेडलिंक

@deadalnix: ठीक है, लेकिन वे std.concurrency का समर्थन करने के लिए बड़े पैमाने पर लगाए गए थे।

— dsimcha

23

एर्लैंग निश्चित रूप से एक शानदार विकल्प है, लेकिन कुछ अधिक व्यावहारिक हो सकता है गो , Google की नई भाषा।

यह अन्य आम भाषाओं से बहुत दूर नहीं है, इसलिए यदि आप पहले से ही अन्य 'आसान' भाषाओं को जानते हैं, तो आमतौर पर इसे प्राप्त करना आसान है। कई लोग इसकी तुलना पायथन या यहां तक कि लुआ से करते हैं कि यह कार्यक्रम कितना आरामदायक है।

— जेवियर
स्रोत

@ अल्फा आवेदन / उपयोगकर्ता स्तर के बारे में पूछ रहा है, न कि सिस्टम समवर्ती प्रोग्रामिंग। एर्लैंग इसे कैसे फिट करता है?

— चिरोन नोव

@ रेयानोस: समुदाय पर निर्भर करता है।

— डोनाल्ड फैलो

@DonalFellows तुम्हारा अधिकार, मुझे लगता है कि मेरा बयान बहुत संकीर्ण था

— रेयानोस

1

@Chiron: एरलैंग एक प्रोग्रामिंग भाषा है, इसका उपयोग एप्लिकेशन बनाने के लिए किया जाता है। आमतौर पर, मल्टीप्रोसेसिंग अनुप्रयोग। मुझे नहीं पता कि यह कहाँ 'सिस्टम समवर्ती proramming' के रूप में फिट है, मैंने एर्लैंग में किसी भी ओएस के बारे में नहीं सुना है।

— जेवियर

1

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

— साकिस

23

.Net के लिए Microsoft के समानांतर प्रोग्रामिंग पर एक नज़र डालें । यह बहुत सहज है।

कई व्यक्तिगत कंप्यूटर और वर्कस्टेशन में दो या चार कोर (यानी सीपीयू) होते हैं जो एक साथ कई थ्रेड्स को निष्पादित करने में सक्षम बनाते हैं। निकट भविष्य में कंप्यूटरों में काफी अधिक कोर होने की उम्मीद है। आज और कल के हार्डवेयर का लाभ उठाने के लिए, आप कई प्रोसेसर में काम वितरित करने के लिए अपने कोड को समानांतर कर सकते हैं। अतीत में, समानांतरकरण में थ्रेड्स और ताले के निम्न-स्तरीय हेरफेर की आवश्यकता होती है। विजुअल स्टूडियो 2010 और .NET फ्रेमवर्क 4 एक नया रनटाइम, नए क्लास लाइब्रेरी प्रकार और नए नैदानिक उपकरण प्रदान करके समानांतर प्रोग्रामिंग के लिए समर्थन बढ़ाता है। ये विशेषताएं समानांतर विकास को सरल बनाती हैं ताकि आप थ्रेड्स या थ्रेड पूल के साथ सीधे काम किए बिना एक प्राकृतिक मुहावरे में कुशल, ठीक-ठीक, और स्केलेबल समानांतर कोड लिख सकें।

— ए ----------------------- -----
स्रोत

+1 यह वही है जो वह पूछ रहा है। हालांकि, जब समस्याएं होती हैं, तो उन्हें निचले स्तर पर संगामिति की समझ के बिना डिबग करना मुश्किल होगा। उल्लेख नहीं करने के लिए, एक सी # शुरुआत के रूप में इसे लेने से साबित हो सकता है ... दिलचस्प।

— पी। ब्रायन। मैके

@ P.Brian.Mackey - मैं सहमत हूँ। हालांकि यह असामान्य नहीं है, यह ORM का उपयोग करने के लिए इसकी तुलना करने के लिए एक खिंचाव नहीं होगा, जब कोई संबंधपरक मॉडल और एसक्यूएल को पूरी तरह से नहीं समझता है ...

— ओट्टोवियो डेसियो

1

विशेष रूप से PLINQ। जबकि यह केवल कार्यों के एक छोटे सबसेट के लिए उपयोगी है, लेकिन इसका उपयोग करना बहुत आसान हो सकता है ।

— svick

21

Erlang और Scala दोनों के पास अभिनेता-आधारित संग़ठन है , जिसे मैंने बहुत सहज और सीखने में आसान पाया।

कंप्यूटर विज्ञान में अभिनेता मॉडल समवर्ती संगणना का गणितीय मॉडल है जो "अभिनेताओं" को समवर्ती डिजिटल संगणना के सार्वभौमिक आदिम के रूप में मानता है: एक संदेश के जवाब में, जो इसे प्राप्त करता है, एक अभिनेता स्थानीय निर्णय ले सकता है, अधिक अभिनेता बना सकता है, अधिक संदेश भेज सकता है , और निर्धारित करें कि प्राप्त किए गए अगले संदेश का जवाब कैसे दिया जाए ... इसका उपयोग कम्प्यूटेशन की सैद्धांतिक समझ के लिए एक फ्रेमवर्क के रूप में किया गया है, और समवर्ती प्रणालियों के कई व्यावहारिक कार्यान्वयन के लिए सैद्धांतिक आधार के रूप में ।

— टीएमएन
स्रोत

19

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

— एलेक्स वेबब्रिज को दर्शाता है
स्रोत

7

Google की GO भाषा में समसामयिकता के लिए कुछ दिलचस्प उपकरण हैं - जो कि कोशिश करने के लिए एक और मजेदार बात होगी। देखें: http://golang.org/doc/effective_go.html#concurrency और उदाहरणों के लिए थोड़ा नीचे पढ़ें।

समवर्ती प्रोग्रामिंग एक बड़ा विषय है और यहां केवल कुछ विशिष्ट विशिष्ट हाइलाइट्स के लिए जगह है।

कई वातावरणों में समवर्ती प्रोग्रामिंग को सूक्ष्मताओं द्वारा साझा चर तक सही पहुंच को लागू करने के लिए कठिन बना दिया जाता है। गो, एक अलग दृष्टिकोण को प्रोत्साहित करता है जिसमें चैनलों पर साझा मूल्यों को पारित किया जाता है और वास्तव में, निष्पादन के अलग-अलग थ्रेड्स द्वारा कभी भी सक्रिय रूप से साझा नहीं किया जाता है। किसी भी समय केवल एक गोरोइन का उपयोग मूल्य तक होता है। डेटा रेस डिज़ाइन द्वारा नहीं हो सकती हैं। इस सोच को प्रोत्साहित करने के लिए हमने इसे एक नारा के रूप में घटाया है:

स्मृति साझा करके संवाद न करें; इसके बजाय, संचार करके स्मृति साझा करें।

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

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

— gnat
स्रोत

6

अगले संस्करण में, C # उस आरेख शो की तुलना में और भी आसान बनाता है। दो नए कीवर्ड हैं Async और Await।

Async एक फ़ंक्शन संशोधक के रूप में उपयोग किया जाता है और कहता है "यह ऑपरेशन किसी अन्य थ्रेड पर अपना काम करता है।

Await का उपयोग एक Async फ़ंक्शन के भीतर किया जाता है, और यह वह जगह है जहाँ जादू होता है। मूल रूप से इंतजार एक अलग थ्रेड में कीवर्ड के बाद ऑपरेशन को चलाने के लिए कंपाइलर को बताता है और परिणामों की प्रतीक्षा करता है। प्रतीक्षा कॉल के बाद कोई भी कोड ऑपरेशन के बाद चलता है।

ALSO, ऑपरेशन कॉलिंग थ्रेड के लिए सिंक्रोनाइज़ करता है (इसलिए यदि आप एक बटन क्लिक के जवाब में एक एसिंक्र ऑपरेशन कर रहे हैं, तो आपको मैन्युअल रूप से UI थ्रेड पर वापस पोस्ट करने की आवश्यकता नहीं है)। दो छोटे कीवर्ड और आपको बहुत सारी कंज्यूमर पावर मिलती है। यहाँ और पढ़ें

— माइकल ब्राउन
स्रोत

किसी भी सभ्य OS C # संकलक पर पहले से ही C # 5, async और इंतजार का समर्थन करें।

— Raynos

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

— sventevit

अच्छी बात। मुझे लगता है कि मैं भी इसके बारे में बोल रहा था। वास्तव में क्या होता है एक "निरंतरता" बनाई जाती है जो "प्रतीक्षा" पूरी होने पर कार्य की घटना की सदस्यता लेती है। और हाँ कुछ निश्चित I / O संचालन और थ्रेड। स्लीप () (जो मूल रूप से घड़ी की रुकावट का जवाब देता है) में एक धागा नहीं है। लेकिन मैन्युअल रूप से बने टास्क के बारे में क्या जो I / O जैसा नहीं है, हम कहते हैं कि हमने एक प्रतीक्षित रिट्रेसमेंट कैलकुलेटर बनाया है? तकनीकी रूप से लेख सही है "कोई धागा नहीं है" लेकिन वास्तव में कभी भी ऐसा नहीं था, यह हमेशा एक अवधारणा थी जिसका उपयोग हम ओएस के हमारे लिए क्या कर रहे थे, इसका विवरण छिपाते थे।

— माइकल ब्राउन

6

मैं अभी भी C ++ की सिफारिश करूंगा। यह सभ्य समवर्ती कोड लिखने के लिए आवश्यक सार से अधिक सक्षम है। भारी संभावना यह है कि आपके पास काम करने के लिए बस एक खराब पुस्तकालय है, क्योंकि नौकरी करने के लिए अच्छी लाइब्रेरी अपेक्षाकृत नए हैं, और वास्तव में, सी ++ कुएं का उपयोग करने के लिए ज्ञान बिल्कुल आम नहीं है। इंटेल का टीबीबी केवल कुछ वर्षों के लिए रहा है, और माइक्रोसॉफ्ट का पीपीएल पिछले साल से ही भेज दिया गया है।

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

— DeadMG
स्रोत

1

Boost.Threads या C ++ 0x std::thread(या std::tr1::thread) देखें। यह वास्तव में एक बहुत अच्छा अमूर्त, IMO है।

— ग्रेफेड

1

@ ग्रेफेड: उनके पास पीपीएल या टीबीबी पर बिल्कुल कुछ नहीं है। boost::threadबस एक छोटा सा RAII के साथ एक OS आवरण है। पीपीएल और टीबीबी वास्तविक समवर्ती एल्गोरिदम, कंटेनर आदि हैं

— डेडएमजी

6

यहाँ Ada के लिए एक प्लग की आवश्यकता है, क्योंकि इसमें समानता और संगति के लिए शीर्ष स्तर के सभी सार हैं। अन्यथा टास्किंग के रूप में जाना जाता है । जैसा कि ओपी ने सहज ज्ञान युक्त (एक व्यक्तिपरक मानदंड!) के लिए कहा, मुझे लगता है कि जावा-केंद्रित दुनिया के लिए एक अलग दृष्टिकोण की सराहना की जा सकती है।

— NWS
स्रोत

5

मेरा सुझाव है कि यदि आप JVM आधारित हो सकते हैं तो मैं Groovy / Java / GPars का सुझाव दूंगा क्योंकि यह अभिनेताओं, डेटाफ़्लो, अनुक्रमिक प्रक्रियाओं (CSP), डेटा समानांतरता, सॉफ़्टवेयर ट्रांसेक्शनल मेमोरी (STM), एजेंटों, के लिए अनुमति देता है ... बिंदु यहाँ है कि कई उच्च-स्तरीय समवर्ती और समानता मॉडल हैं, जिनमें से प्रत्येक में अलग-अलग "मीठे स्पॉट" हैं। आप एक ऐसी मॉडल का उपयोग नहीं करना चाहते हैं जो आपके द्वारा बनाई गई समस्या के समाधान के अनुरूप नहीं है। केवल एक मॉडल के साथ भाषा और रूपरेखा आपको एल्गोरिथ्म हैकिंग में ले जाती है।

निश्चित रूप से मुझे पक्षपाती के रूप में देखा जा सकता है क्योंकि मैं ग्रूवी और जीपर्स का योगदानकर्ता हूं। दूसरी तरफ मैं सीएसपी और पायथन के साथ काम करता हूं, सीएफ। अजगर-सीएसपी।

एक और मुद्दा यह है कि मूल प्रश्न सीखने के बारे में है, न कि उत्पादन प्रणाली लिखने के बारे में। तो Groovy / Java / GPars संयोजन सीखने का एक अच्छा तरीका है, भले ही JVM आधारित होने के बजाय C :: ++ में केवल :: थ्रेड प्रो या टीबीबी जैसे कुछ का उपयोग करके उत्पादन कार्य किया जाता है।

(होस्ट साइट द्वारा स्पैमिंग के बारे में कुछ घबराहट के कारण कुछ पूरी तरह से उचित यूआरएल लिंक को हटाया जाना था।)

— रसेल विंडर
स्रोत

रसेल, यदि आप चाहें, तो आप मुझे बता सकते हैं कि आप चैट रूम में क्या लिंक चाहते हैं और मैं उन्हें आपके लिए जोड़ूंगा

— Dan McGrath

4

क्लोजर के बारे में क्या? आप उदाहरण के लिए स्विंग का उपयोग कर सकते हैं लेकिन क्लोजर समवर्ती प्रोग्रामिंग सुविधा का आनंद ले रहे हैं? क्लोजर में बहुत अच्छा जावा एकीकरण है।

इसके अलावा, क्या आपने जावा 7 फोर्क / जॉइन फ्रेमवर्क पर विचार किया है ?

— चीरों
स्रोत

2

तुम भी Groovy और GPars पुस्तकालय को देखना चाहते हो सकता है । GPars BTW एक अन्य उत्तर में उल्लिखित .NET पैरेलल एक्सटेंशन के समान है, लेकिन Groovys लचीली सिंटैक्स इसे कुछ परिस्थितियों में बेहतर पढ़ता है।

— क्रिश्चियन हॉर्सडाल
स्रोत

0

स्काला का उल्लेख कई बार प्रश्नों और उत्तरों में किया गया है, लेकिन मैंने अक्का का कोई संदर्भ नहीं देखा है, जो कि एक अभिनेता कार्यान्वयन है, जिसका उपयोग स्काला और जावा दोनों के साथ किया जा सकता है।

— जियोर्जियो
स्रोत

इस उत्तर में क्या गलत है? कोई अन्य उत्तर में उल्लेख नहीं किया गया है, और अक्का समवर्ती प्रोग्रामिंग के लिए एक उच्च-स्तरीय अमूर्तता को लागू करता है।

— जियोर्जियो

-1

मुझे लगता है कि यह इस बात पर निर्भर करता है कि आप क्या कर रहे हैं। डेस्कटॉप ऐप्स, या सर्वर? मैंने सुना है कि (लेकिन व्यक्तिगत अनुभव नहीं है) नोड्स। सर्वर के लिए समवर्ती प्रोग्रामिंग के लिए बहुत अच्छा है (दोनों कोड लिखने और प्रदर्शन में)। अगर मैं एक नया सर्वर ऐप लिखना चाहता था, तो मैं शायद यही कोशिश करूंगा। डेस्कटॉप ऐप्स के बारे में निश्चित नहीं ... मैंने सी # में सामान की एक उचित मात्रा लिखी है और कुछ उपकरण हैं जो जटिलता को अच्छी तरह से छिपाते हैं, हालांकि अन्य मामलों के लिए आपको इसके साथ सामना करना पड़ता है।

— Aerik
स्रोत

-1

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

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

एक अच्छा सबप्रोसेसन लाइब्रेरी ढूंढें, जैसे कि अजगर के लिए दूत । या आप सिर्फ C में कई अलग-अलग प्रोग्राम लिख सकते हैं, और उपप्रकारों के साथ स्पॉन और संवाद करने के लिए कांटा और पाइप का उपयोग करने के लिए एक और "मास्टर" प्रोग्राम लिख सकते हैं ।

— स्पेंसर रथबुन
स्रोत

3

यह ओपी स्पष्ट रूप से चाहता है के विपरीत है ... एक प्रक्रिया को spawning मैन्युअल रूप से एक धागा spawning के रूप में कम स्तर के रूप में है। ओपी कंसीव करने के उच्च-स्तरीय अमूर्त में रुचि रखता है ।

— कोनराड रूडोल्फ