क्या मैं बूस्ट :: थ्रेडपूल का उपयोग 'थ्रेड-सुरक्षित कतार' के रूप में कर सकता हूं?

Question

क्या मैं जरूरत है वास्तव में एक धागा सुरक्षित कतार संरचना है, जहां कई ग्राहकों और कतार में डंपिंग डेटा रखने एक काम कर धागा प्रसंस्करण रहता है और कतार

पॉपिंग वहाँ है किसी भी अच्छी तरह से स्थापित समाधान एसटीएल में मौजूदा है या बढ़ावा?

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

Answer 1

बूस्ट में message queue class है, जो आपको चाहिए: थ्रेड-सुरक्षित कतार।

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

Answer 2

यदि आपको एक प्रक्रिया प्रक्रिया में ऐसे ढांचे की आवश्यकता है, तो boost :: asio :: io_service पर्याप्त होना चाहिए। बूस्ट :: थ्रेड और बूस्ट :: asio :: io_service का उपयोग कर एक वर्किंग बॉक्स नमूना वर्ग यहां दिया गया है।

#include <boost/asio.hpp> 
#include <boost/bind.hpp> 
#include <boost/thread.hpp> 

class IWorkerThreadJob 
{ 
    public: 
     virtual ~IWorkerThreadJob(){}; 
     virtual void execute() = 0; 
}; 


class BoostBasedWorkingBox 
{ 
    public: 

     BoostBasedWorkingBox(): 
      m_IOServiceWork(m_IOService), // Give some work to io_service or else it will simply return from ::run method . 
      m_WorkerThread(boost::bind(&boost::asio::io_service::run, &m_IOService)) 
     {} 

     ~BoostBasedWorkingBox() 
     { 
      m_IOService.stop(); 
      m_WorkerThread.join(); 
     } 

     void processJob(IWorkerThreadJob* pJob) 
     { 
      m_IOService.post(boost::bind(&IWorkerThreadJob::execute,pJob)); 
     } 

    protected: 
     boost::thread m_WorkerThread; 
     boost::asio::io_service m_IOService; 
     boost::asio::io_service::work m_IOServiceWork; 


} 

का उपयोग करें: - IWorkerThreadJob इंटरफेस को लागू करें। एकाधिक प्रक्रियाओं से कॉल प्रक्रिया जॉब विधि।

यहां बढ़ावा दें :: asio :: io_service थ्रेड सुरक्षित कतार के रूप में कार्य करता है।

Answer 3

यदि आप विंडोज़ पर हैं तो आप ppl.h (vS2010 के लिए नया) में concurrent_queue का उपयोग कर सकते हैं। यदि आप विंडोज़ पर नहीं हैं तो आप इंटेल के थ्रेड बिल्डिंग ब्लॉक में concurrent_queue.h का उपयोग कर सकते हैं।

एंथनी विलियम्स भी कंडीशन वेरिएबल on his blog पर आधारित कतार है जो अच्छा है।