मुझे लगातार बनाए गए धागे के निष्पादन के आदेश में कोई समस्या है। यहां कोड है।बढ़ावा :: थ्रेड निष्पादन आदेश
#include <iostream>
#include <Windows.h>
#include <boost/thread.hpp>
using namespace std;
boost::mutex mutexA;
boost::mutex mutexB;
boost::mutex mutexC;
boost::mutex mutexD;
void SomeWork(char letter, int index)
{
boost::mutex::scoped_lock lock;
switch(letter)
{
case 'A' : lock = boost::mutex::scoped_lock(mutexA); break;
case 'B' : lock = boost::mutex::scoped_lock(mutexB); break;
case 'C' : lock = boost::mutex::scoped_lock(mutexC); break;
case 'D' : lock = boost::mutex::scoped_lock(mutexD); break;
}
cout << letter <<index << " started" << endl;
Sleep(800);
cout << letter<<index << " finished" << endl;
}
int main(int argc , char * argv[])
{
for(int i = 0; i < 16; i++)
{
char x = rand() % 4 + 65;
boost::thread tha = boost::thread(SomeWork,x,i);
Sleep(10);
}
Sleep(6000);
system("PAUSE");
return 0;
}
हर बार (डी करने के लिए एक से) एक पत्र और एक genereaion आईडी (i) एक धागे के रूप में विधि SomeWork को पारित कर दिया है। मुझे पत्रों के बीच निष्पादन आदेश की परवाह नहीं है, लेकिन एक प्रख्यात पत्र के लिए, ए कहें, एक्स को पहले से शुरू करना है, यदि x < y। कोड के एक यादृच्छिक उत्पादन के एक यादृच्छिक हिस्सा है:
B0 started D1 started C2 started A3 started B0 finished B12 started D1 finished D15 started C2 finished C6 started A3 finished A9 started B12 finished B11 started --> B11 started after B12 finished. D15 finished D13 started C6 finished C7 started A9 finished
कैसे इस तरह की स्थितियों से बच सकते हैं?
धन्यवाद।
मैंने स्थिति चर का उपयोग कर समस्या हल की। लेकिन मैंने समस्या को थोड़ा सा बदल दिया। समाधान लूप के सूचकांक का ट्रैक रखना है। इसलिए प्रत्येक धागा जानता है कि यह काम नहीं करता है। लेकिन जहां तक इस कोड का सवाल है, वहां दो अन्य चीजें हैं जिन्हें मैं पूछना चाहता हूं।
सबसे पहले, मेरे कंप्यूटर पर, जब मैंने 350 के लिए फॉर-लूप इंडेक्स सेट किया था तो मुझे एक्सेस उल्लंघन था। 310 लूप की संख्या थी, जो ठीक था। इसलिए मुझे एहसास हुआ कि उत्पन्न होने के लिए अधिकतम संख्या में धागे हैं। मैं इस नंबर को कैसे निर्धारित कर सकता हूं? दूसरा, विजुअल स्टूडियो 2008 में, कोड के रिलीज़ संस्करण ने वास्तव में अजीब व्यवहार दिखाया। हालत चर का उपयोग किए बिना (लाइन 1 से 3 टिप्पणी की गई थी), धागे का आदेश दिया गया था। यह कैसे हो सकता है?
यहाँ कोड है: आप दो अलग-अलग लॉक के लिए इंतज़ार कर धागे है, तो
#include <iostream>
#include <Windows.h>
#include <boost/thread.hpp>
using namespace std;
boost::mutex mutexA;
boost::mutex mutexB;
boost::mutex mutexC;
boost::mutex mutexD;
class cl
{
public:
boost::condition_variable con;
boost::mutex mutex_cl;
char Letter;
int num;
cl(char letter) : Letter(letter) , num(0)
{
}
void doWork(int index, int tracknum)
{
boost::unique_lock<boost::mutex> lock(mutex_cl);
while(num != tracknum) // line 1
con.wait(lock); // line 2
Sleep(10);
num = index;
cout << Letter<<index << endl;
con.notify_all(); // line 3
}
};
int main(int argc , char * argv[])
{
cl A('A');
cl B('B');
cl C('C');
cl D('D');
for(int i = 0; i < 100; i++)
{
boost::thread(&cl::doWork,&A,i+1,i);
boost::thread(&cl::doWork,&B,i+1,i);
boost::thread(&cl::doWork,&C,i+1,i);
boost::thread(&cl::doWork,&D,i+1,i);
}
cout << "************************************************************************" << endl;
Sleep(6000);
system("PAUSE");
return 0;
}
कार्य इकाइयों का क्या मतलब है? –
धागे द्वारा किए जाने वाले काम के टुकड़े का कुछ प्रतिनिधित्व। इस मामले में, एक कार्य इकाई मूल रूप से '(पत्र, सूचकांक) 'जोड़ी होगी। – Gian