वापसी मूल्य

Question

के साथ एक सिंक्रोनस विधि के साथ असीमित कॉल की एक श्रृंखला को लपेटना मेरा वर्तमान कोड परिणाम में समाप्त होने वाली असीमित प्रक्रियाओं की श्रृंखला का उपयोग करता है। मुझे इनमें से प्रत्येक को इस तरह से लपेटने की ज़रूरत है कि प्रत्येक को एक सिंक्रोनस विधि द्वारा रिटर्न वैल्यू के रूप में उपयोग किया जाता है। मैं ऐसा करने के लिए निष्पादक सेवाओं का उपयोग करना चाहता हूं, ताकि इनमें से कई एक ही समय में हो सकें। मुझे लगता है कि भविष्य मेरे कार्यान्वयन के लिए प्रासंगिक हो सकता है, लेकिन मैं ऐसा करने के लिए एक अच्छा तरीका नहीं समझ सकता।

मैं अब क्या है:

public class DoAJob { 
    ResultObject result; 

    public void stepOne() { 
    // Passes self in for a callback 
    otherComponent.doStepOne(this); 
    } 

    // Called back by otherComponent once it has completed doStepOne 
    public void stepTwo(IntermediateData d) { 
    otherComponent.doStepTwo(this, d); 
    } 

    // Called back by otherComponent once it has completed doStepTwo 
    public void stepThree(ResultObject resultFromOtherComponent) { 
    result = resultFromOtherComponent; 
    //Done with process 
    } 
} 

यह आंतरिक रूप से बहुत अच्छी तरह से काम किया है, लेकिन अब मैं की तरह एक वापसी मान वाला एक तुल्यकालिक विधि में मेरी प्रक्रिया मैप करने की आवश्यकता:

public ResultObject getResult(){ 
    // ??? What goes here ??? 
} 

किसी को भी करता है इस सुन्दर तरीके से कार्यान्वित करने के बारे में एक अच्छा विचार है?

Answer 1

मैंने गुवा पुस्तकालय के साथ कुछ ऐसा किया है; इन कड़ियों सही दिशा में इंगित कर सकता है:

Is it possible to chain async calls using Guava?

https://code.google.com/p/guava-libraries/wiki/ListenableFutureExplained

Answer 2

मैं invokeAll(..) उपयोग करना चाहिये। यह निष्पादक को कार्यों का एक सेट सबमिट करेगा, और आखिरी बार पूरा होने तक ब्लॉक (सफलतापूर्वक/अपवाद के साथ)। इसके बाद यह पूर्ण भविष्य की वस्तुओं की एक सूची लौटाता है, ताकि आप उन पर लूप कर सकें और परिणामों को एकल परिणाम ऑब्जेक्ट में विलय कर सकें।

में आप एक तुल्यकालिक ढंग से केवल एक ही काम चलाना चाहते हैं, तो आपको निम्न का उपयोग कर सकते हैं:

executor.invokeAll(Collections.singleton(task)); 

--edit--

अब मुझे लगता है कि मैं बेहतर अपनी आवश्यकताओं को समझते हैं। मुझे लगता है कि आपको कार्यों के स्वतंत्र अनुक्रम सबमिट करने का एक तरीका चाहिए। कृपया this answer में पोस्ट किए गए कोड को देखें।

Answer 3

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

1. एक अवरुद्ध कतार जो सिर्फ एक तत्व पकड़ कर सकते हैं परिभाषित करें:

   BlockingQueue<Result> blockingQueue = new ArrayBlockingQueue<Result>(1);

2. अपने अतुल्यकालिक प्रक्रिया प्रारंभ करें (पृष्ठभूमि में चला जाएगा), और कॉलबैक ऐसी है कि इसके पूर्ण होने पर लिखते हैं, यह इसके परिणाम को ब्लॉकिंग कतार में जोड़ता है।

   Result result = blockingQueue.take();

मैं ऐसी ही कुछ लिखा से पहले (अग्रभूमि धागा जरूरतों:

अपने अग्रभूमि/आवेदन धागा में, यह पंक्ति है, जो ब्लॉक जब तक एक तत्व उपलब्ध हो जाता है से ले() है रिमोट मशीन से एसिंक्रोनस प्रतिक्रिया के लिए अवरुद्ध करने के लिए) भविष्य की तरह कुछ उपयोग करके, आप उदाहरण कोड here पा सकते हैं।

Answer 4

आप अपने हाथों गंदा प्राप्त करना चाहते, तो आप इस

ResultObject result; 

public void stepOne() 

    otherComponent.doStepOne(this); 

    synchronized(this) 
     while(result==null) this.wait(); 
    return result; 

public void stepThree(ResultObject resultFromOtherComponent) 

    result = resultFromOtherComponent; 

    synchronized(this) 
     this.notify(); 

कर सकते हैं या आप उच्च स्तर संगामिति उपकरण, BlockingQueue, सेमाफोर, CountdownLatch, Phaser, वगैरह वगैरह

नोट की तरह उपयोग कर सकते हैं कि DoAJob धागा सुरक्षित नहीं है - एक ही समय में दो धागे stepOne पर कॉल करते समय परेशानी सुनिश्चित की गई।