मल्टीथ्रेडेड ऑब्जर्वर पैटर्न

Question

मेरे पास एक प्रश्न है जहां हर विषय एक अलग थ्रेड में एक विषय अपडेट किया जाता है। इसलिए जब भी विषय अपडेट किया जाता है तो यह नई जानकारी के साथ पर्यवेक्षक को संगत रूप से अद्यतन करता है। हालांकि, अगर पर्यवेक्षकों की सूची लंबी है, तो सभी पर्यवेक्षकों को अपडेट करने के लिए कुछ समय की आवश्यकता होगी। एक विषय के बारे में सोचें जो अक्सर अद्यतन हो जाता है। जबकि विषय पर्यवेक्षकों को अद्यतन कर रहा है, "विषय" ऑब्जेक्ट लॉक है और इसलिए किसी भिन्न थ्रेड द्वारा अपडेट नहीं किया जा सकता है। यह या तो विषय के लिए सूचना यातायात पैदा करेगा या जानकारी के नुकसान का कारण बन जाएगा।

क्या आपको कोई विचार है कि बहु-थ्रेडेड वातावरण में इन मुद्दों को कैसे नियंत्रित किया जाता है? साथ ही, क्या कोई सी ++ के साथ समांतर प्रोग्रामिंग पर कुछ किताबों की सिफारिश कर सकता है?

Answer 1

producer-consumer queues या message queues के उपयोग पर विचार करें। आपके उदाहरण के लिए, आप दो तरह से एक कतार उपयोग कर सकते हैं: विषय को

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

2. पर्यवेक्षकों को अधिसूचनाएं कतारबद्ध हैं। प्रत्येक पर्यवेक्षक के पास एक कतार है जहां विषय परिवर्तन-परिवर्तन अधिसूचनाएं पोस्ट की जाती हैं।

आप क्यूटी लाइब्रेरी का उपयोग कर रहे हैं, तो आप Qt::QueuedConnection कनेक्शन प्रकार के साथ संकेत & स्लॉट्स तंत्र का उपयोग कर सकते हैं। स्लॉट रिसीवर की घटना कतार के माध्यम से जाता है और रिसीवर के धागे में निष्पादित किया जाता है। इस तरह, प्रेषक ब्लॉक नहीं करता है जबकि रिसीवर अपने संबंधित स्लॉट निष्पादित करते हैं।

आपका प्रोग्राम Actor model (paradigm) के लिए एक अच्छा उम्मीदवार हो सकता है। यहाँ कुछ सी ++ पुस्तकालयों कि अभिनेता मॉडल को लागू कर रहे हैं:

• Theron
• libcppa (सी ++ 11 के आधार पर)
• Asynchronous Agents Library (माइक्रोसॉफ्ट)

आपका कार्यक्रम भी एक अच्छे उम्मीदवार हो सकता है Dataflow प्रतिमान के लिए। प्रस्तावित Boost Dataflow लाइब्रेरी देखें, जो threading का समर्थन करता है।

---

मैं सिफारिश करने के लिए एक किताब नहीं है, लेकिन हर्ब सुतर की series of Dr Dobbs articles सी पर ++ संगामिति की जाँच करें।

Answer 2

मैं जावा

 

    import java.lang.reflect.Method; 
    import java.util.List; 
    import java.util.Map; 
    import java.util.Map.Entry; 

    /** 
    * An observer pattern that allows listeners to register(), unregister() in 
    * multiple threads and also notify listeners in another thread. 
    * 
    * A HashMap keeps track of the listeners and their status (active, obsolete). 
    * When a listener unregister, its entry is marked as obsolete in this map. 
    * 
    * During firing of an event, the observer notifies all the listeners that are 
    * active, the active status will be stored in a Boolean that's synchronized so 
    * rare race conditions like calling notify on an active listener that has just 
    * turned obsolete will not happen. 
    * 
    * 
    */ 
    public class MultithreadedObserverPattern { 

     interface Handler { 
      void handleEvent(T listener); 
     } 

     class BooleanHolder { 
      boolean val; 

      BooleanHolder(boolean v) { 
       val = v; 
      } 

      void set(boolean v) { 
       val = v; 
      } 

      boolean get() { 
       return val; 
      } 
     } 

     Map listeners = new HashMap(); 

     public void register(AbstractListener l) { 
      synchronized (listeners) { 
       listeners.put(l, new BooleanHolder(true)); 
      } 
     } 

     public void unregister(AbstractListener l) { 
      synchronized (listeners) { 
       BooleanHolder status = listeners.get(l); 
       if (status != null) { 
        // notify call also syncing on status 
        synchronized (status) { 
         status.set(false); 
        } 
       } 
       // set to false 
      } 
     } 

     public void notifyAll(Handler handler) { 
      // here we do not synchroznie on listeners to avoid tricky lock situations 
      // make a copy of the map 
      List> activeListeners = new ArrayList>(); 
      List inactiveListeners = new ArrayList(); 

      synchronized (listeners) { 
       for (Entry entry : listeners.entrySet()) { 
        if (entry.getValue().get()) { 
         activeListeners.add(entry); 
        } else { 
         inactiveListeners.add(entry.getKey()); 
        } 
       } 
      } 
      // call the method on active listener 
      // 
      for (Entry e : activeListeners) { 
       BooleanHolder status = e.getValue(); 
       // remove those listeners that are no longer active 
       synchronized (status) { 
        if (status.get()) { 
          handler.handleEvent(e.getKey()); 
        } 
       } 
      } 

      synchronized (listeners) { 
       // remove inactive listeners 
       for (AbstractListener l : inactiveListeners) { 
        listeners.remove(l); 
       } 
      } 
     } 
    }