कई थ्रेड

Question

के साथ QtConcurrent बनाम QThread का मल्टीथ्रेडिंग प्रदर्शन मान लीजिए कि आपके एप्लिकेशन को एकाधिक थ्रेड में फ़ंक्शन चलाने की आवश्यकता है, जिसकी संख्या CPU कोर/थ्रेड की संख्या से अधिक है।

for(int i=0;i<30;i++) 
{ 
     MyClass *obj = new MyClass; 
     QThread *th = new QThread(); 
     obj->moveToThread(th); 
     connect(th, SIGNAL(started()), obj, SLOT(someFunction())); 
     connect(obj, SIGNAL(workFinished()), th, SLOT(quit())); 
     connect(th, SIGNAL(finished()), obj, SLOT(deleteLater())); 
     connect(th, SIGNAL(finished()), th, SLOT(deleteLater())); 

     th->start(); 
} 

धागे की संख्या के रूप में और अधिक कर रहे हैं:

MyClass *obj = new MyClass; 

QThreadPool::globalInstance()->setMaxThreadCount(30); 

for(int i=0;i<30;i++) 
    QtConcurrent::run(obj, &MyClass::someFunction); 

एक और तरीका है एक से अधिक ऑब्जेक्ट moveToThread का उपयोग कर सकते हैं और विभिन्न धागे को स्थानांतरित करने के लिए है: एक तरह से QtConcurrent उपयोग करें और अधिकतम धागा गिनती की स्थापना करने के लिए है सीपीयू कोर की संख्या से, चलते समय विभिन्न कोरों के बीच धागे को स्विच किया जाना चाहिए।

सवाल यह है कि क्या दोनों दृष्टिकोणों के अलग-अलग प्रदर्शन हैं या नहीं? i.e QThread का स्विचिंग QtConcurrent::run का उपयोग करके चलाए जाने वाले एक से अलग है?

Answer 1

मैं पहले उत्तर से सहमत हूं, लेकिन मैं कुछ जोड़ना चाहता हूं।

QThread निम्न स्तर की कक्षा है जो केवल ओएस-विशिष्ट कार्यों को चलाती है। QtConcurrent क्या है? उत्तर Qt स्रोत कोड में है।

प्रथम स्तर: run

QFuture<T> run(T (*functionPointer)()) 
{ 
     return (new StoredFunctorCall0<T, T (*)()>(functionPointer))->start(); 
} 

Second:

struct StoredFunctorCall0: public RunFunctionTask<T> { ... 

Third:

template <typename T> 
class RunFunctionTaskBase : public QFutureInterface<T> , public QRunnable 
{ ... 

अब के बारे में QRunnable। जब हम QThreadPool साथ QRunnable शुरू हम करते हैं:

start() जो tryStart() जो startThread() जिसके साथ QThreadPoolThread (और यह एक QThread subclass है) संचालित कॉल कॉल करता है और यह अंत में QThread की start() फोन कर रहा है।

और निश्चित रूप से यह श्रृंखला पूर्ण, लंबी सड़क नहीं है, है ना? इसलिए जैसा कि मुझे पता है, जब हम अमूर्तता का उपयोग करते हैं, तो हमारे पास अमूर्त जुर्माना होता है (QtConcurrent में QThread का बड़ा जुर्माना है), लेकिन अंतिम परिणाम समान है, यह QThread है।

Answer 2

संक्षिप्त उत्तर: यह वर्कलोड की प्रकृति/तर्क पर निर्भर करता है।

QtConcurrent धागे का एक पूल से चलाता है और यह एक उच्च स्तर एपीआई नहीं अवरुद्ध संचालन की एक बड़ी संख्या को चलाने के लिए अच्छी तरह से अनुकूल है: आप जल्द ही पूल से समाप्त हो रही है और हो रही है खत्म हो जाएगा अगर आप संचालन अवरुद्ध करने का एक बहुत कुछ कर अन्य अनुरोध कतारबद्ध उस स्थिति में QThread (निचला स्तर का निर्माण) शायद ऑपरेशन के लिए बेहतर अनुकूल है (प्रत्येक एक एकल धागे का प्रतिनिधित्व करता है)।