कतार

Question

अपने talk में 54:53 मिनट के निशान पर उपयोग करने वाले प्रोग्राम, रिच हिकी निर्भर कार्यक्रम भागों को कम करने के साधन के रूप में कतारों के उपयोग के बारे में बात कर रहा है।

// Warning: Java-pseudo-code ahead 
class Job { 
    public void doRun(A a) { 
     saveObjectToDatabase(a); 

     B b = computeB(a); 
     saveObjectToDatabase(b); 

     C c = computeC(b); 
     logToFile(c); 
    } 
} 

saveObjectToDatabase और saveObjectToDatabase दुष्प्रभाव के साथ एक विधि के रूप में देखा जा सकता है: क्या आप मुझे यह डिजाइन और/या लचीलापन है सुधार करने के लिए कैसे जावा-छद्म कोड का निम्न भाग deouple करने पर एक उदाहरण दे सकते हैं , जबकि computeB और computeC का आउटपुट केवल a पर निर्भर करता है।

मुझे पता है कि यह प्रश्न अस्पष्ट/व्यापक है। मैं अपने कार्यक्रम को बड़े पैमाने पर जटिल किए बिना क्यूइंग तंत्र का लाभ उठाने के बारे में महसूस करना चाहता हूं और अभी भी यह सुनिश्चित कर रहा हूं कि यह सही क्रम में सही काम करता है। सही दिशा में किसी भी संकेतक की सराहना की जाती है।

Answer 1

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

एक पहली प्रक्रिया, "बाहर की दुनिया" से अपने a वस्तुओं प्राप्त होगा और उन्हें कतार 1. एक दूसरा प्रक्रिया कतार 1 से वस्तुओं विपंक्ति हैं में enqueue computeB करते हैं, और कतार 2. एक तिहाई होगा प्रक्रिया पर परिणाम enqueue कतार 2 से dequeue वस्तुओं, computeC प्रदर्शन, और परिणाम या जो कुछ भी लॉग इन करें।

निर्भर करता है, जैसा कि मैंने कहा, शामिल डेटा की मात्रा पर (और शायद कुछ अन्य कारकों) "वस्तुओं" कतारों में पारित कर दिया या तो अपने वास्तविक a और b वस्तुओं हो सकता है या फिर सिर्फ टोकन/कुंजी खोजने के लिए डेटाबेस में डेटा।

कतार स्वयं को कई तरीकों से लागू किया जा सकता है। डेटाबेस के साथ एक कतार लागू करना संभव है, उदाहरण के लिए, हालांकि विवरण गन्दा हो जाते हैं। "प्रक्रिया" जावा कार्यों को एक एकल जावा प्रक्रिया में हो सकती है या अलग-अलग मशीनों पर भी अलग ओएस प्रक्रिया हो सकती है।

जब आप यूनिक्स पर "पाइप" का उपयोग करते हैं तो आप इस फैशन में कतारों का प्रभावी ढंग से उपयोग कर रहे हैं।

Answer 2

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

घटना-संचालित होने के मामले में, प्रत्येक घटक सूचित करता है कि किस प्रकार के ईवेंट \ संदेश वह सुनना चाहते हैं। आपके पास एक प्रेषक है जो आने वाले संदेशों को इकट्ठा करता है और उन्हें रिसीवर की कतार में डाल देता है। रिसीवर प्रक्रिया, और अंत में नए संदेश उत्पन्न करते हैं। और आदि ...

आपके मामले में, कुछ इस तरह:

class SaveObjectHandler{ 
// 
void handle(Event e, Object o){ 
    if(e instanceof SaveEvent) 
     saveObjectToDatabase(o); 
} 

}; 

class TransformObject{ 
// 
void handle(Event e,Object o){ 
    if(e instanceof TransformEvent){ 
     B result = compute(o); 
     send(new SaveEvent(),result) 
    } 

} 

}; 

class Logger{ 

    void handle(Event e, Object o){ 
     if(o instanceof B) 
     //perform computeC 
     logEvent((B)o); 
    } 

}; 

};

प्रश्न में पुस्तकालय SEDA है।

Answer 3

मैं सहेजने से डरता हूं ऑब्जेक्ट विधियों के दुष्प्रभाव वाले आप इसे अच्छी तरह से कम से कम नहीं कर सकते हैं या कम से कम नहीं।

लेकिन कहें कि आपको डेटाबेस को कुछ वस्तुओं को तेज़ी से लिखने की आवश्यकता है।मेरी राय यह है कि रिलेशनल डीबी के साथ सबसे तेज़ तरीका ऑब्जेक्ट्स को कई क्लाइंट्स द्वारा कतार में सहेजना चाहिए और उन्हें एक या दो सुंदर तेज़ लेखकों द्वारा डेटा को डेटा को जितनी जल्दी हो सके डेटा को धक्का देना चाहिए।

मैं इस विषय पर और अधिक शोध कर रहा हूँ और अंत में निष्कर्ष पर पहुंचा, विधि untangling कि:

Answer 4

पूर्णता के लिए के लिए, मैं गर्म licks 'जवाब देने के लिए कुछ और जानकारी जोड़ना चाहते हैं जाने का रास्ता है। मैं उत्पादकों/उपभोक्ताओं/विषयों के काफ्का शब्दावली का उपयोग करूँगा।

समाधान 1

:



उदाहरण पोस्ट की मेरी विशिष्ट प्रश्न के बारे में, वहाँ इसे हल करने के दो तरीके हैं: अधिक जानकारी के लिए The Log: What every software engineer should know about real-time data's unifying abstraction और विशेष रूप से इस ग्राफिक देखना

• उपभोक्ता 1:
  • फ्रो एम विषय a
  • डेटाबेस में सहेजें।
• उपभोक्ता 2:
  • डेटाबेस से बचाने विषय a
  • गणना b
  • से खपत करते हैं।
• उपभोक्ता 3: डेटाबेस के लिए बचाने विषय a
  • गणना b
  • गणना c
  • से उपभोग

यह कंप्यूटिंग bदो बार का नुकसान है। छद्म कोड में:

class ConsumerA { 
    public void consume(A a) { 
     saveObjectToDatabase(a); 
    } 
} 

class ConsumerB { 
    public void consume(A a) { 
     B b = computeB(a); 
     saveObjectToDatabase(b); 
    } 
} 

class ConsumerLog { 
    public void consume(A a) { 
     B b = computeB(a); 
     C c = computeC(b); 
     logToFile(c); 
    } 
} 

समाधान 2

• उपभोक्ता 1:
  • डेटाबेस से बचाने विषय a
  • से खपत करते हैं।
• उपभोक्ता 2:
  • विषय a
  • गणना b से उपभोग करते हैं, डेटाबेस
  • को बचाने के लिए एक अलग विषय b को b प्रकाशित करते हैं।
• उपभोक्ता 3:
  • विषय से उपभोग b
  • गणना c
  • logToFile c

छद्म कोड में:

class ConsumerA { 
    public void consume(A a) { 
     saveObjectToDatabase(a); 
    } 
} 

class ConsumerB { 
    public void consume(A a) { 
     B b = computeB(a); 
     saveObjectToDatabase(b); 
     publish(b); // republish computed information to another topic b 
    } 
} 

class ConsumerLog { 
    public void consume(B b) { 
     C c = computeC(b); 
     logToFile(c); 
    } 
}