यदि कोई दूसरा विफल रहता है तो एक कार्य को रद्द करने के लिए दो समानांतर कार्य कैसे लिखें?

Question

मैं scalaz.concurrent.Task के साथ अपनी एसिंक्रोनस प्रोसेसिंग को कार्यान्वित करना चाहता हूं। मैं इस प्रकार एक नया कार्य है कि काम करता है वापस जाने के लिए एक समारोह (Task[A], Task[B]) => Task[(A, B)] की जरूरत है:

• रन Task[A] और Task[B] समानांतर में और परिणाम के लिए इंतजार;
• यदि कोई कार्य विफल रहता है तो को रद्द करें और इसे समाप्त होने तक प्रतीक्षा करें;
• दोनों कार्यों के परिणाम लौटाएं।

आप इस तरह के फ़ंक्शन को कैसे कार्यान्वित करेंगे?

Answer 1

जैसा कि मैंने उपरोक्त उल्लेख किया है, यदि आप वास्तव में गैर-असफल गणना को रोकने के बारे में परवाह नहीं करते हैं, तो आप कर सकते हैं Nondeterminism का उपयोग करें।

import scalaz._, scalaz.Scalaz._, scalaz.concurrent._ 

def pairFailSlow[A, B](a: Task[A], b: Task[B]): Task[(A, B)] = a.tuple(b) 

def pairFailFast[A, B](a: Task[A], b: Task[B]): Task[(A, B)] = 
    Nondeterminism[Task].both(a, b) 

val divByZero: Task[Int] = Task(1/0) 
val waitALongTime: Task[String] = Task { 
    Thread.sleep(10000) 
    println("foo") 
    "foo" 
} 

और फिर:

pairFailSlow(divByZero, waitALongTime).run // fails immediately 
pairFailSlow(waitALongTime, divByZero).run // hangs while sleeping 
pairFailFast(divByZero, waitALongTime).run // fails immediately 
pairFailFast(waitALongTime, divByZero).run // fails immediately 

waitALongTime में पहली पक्ष प्रभाव क्या होगा छोड़कर हर मामले में उदाहरण के लिए। यदि आप उस गणना को रोकने का प्रयास करना चाहते हैं, तो आपको Task के runAsyncInterruptibly जैसे कुछ उपयोग करने की आवश्यकता होगी।

Answer 2

जावा डेवलपर्स के बीच एक अजीब अवधारणा है कि आपको समांतर कार्यों को रद्द नहीं करना चाहिए। वे Thread.stop() शुरू करते हैं और इसे बहिष्कृत करते हैं। Thread.stop() के बिना आप वास्तव में भविष्य को रद्द नहीं कर सके। आप जो कुछ भी कर सकते हैं वह भविष्य में कुछ संकेत भेजना है, या कुछ साझा चर को संशोधित करना और भविष्य में कोड को समय-समय पर जांचना है। इसलिए, वायदा प्रदान करने वाले सभी पुस्तकालय भविष्य को रद्द करने का एकमात्र तरीका सुझा सकते हैं: इसे सहकारी रूप से करें।

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

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