थ्रेडिंग मॉड्यूल में एक ही प्रोग्राम अलग आउटपुट

Question

start.py कोड नीचे जैसा है।

import threading 
class myThread(threading.Thread): 
     def __init__(self, threadID, name): 
       threading.Thread.__init__(self) 
       self.threadID = threadID 
       self.name = name 

     def run(self): 
       currentThreadname = threading.currentThread() 
       print "running in ", currentThreadname 

thread = myThread(1,"mythrd") 
thread.start() 

इसे दो बार पाइथन के साथ शुरू करें।

python start.py 
running in <myThread(mythrd, started 140461133485824)> 
python start.py 
running in <myThread(mythrd, started 140122860668672)> 

run.py कोड नीचे जैसा है।

import threading 
class myThread(threading.Thread): 
     def __init__(self, threadID, name): 
       threading.Thread.__init__(self) 
       self.threadID = threadID 
       self.name = name 

     def run(self): 
       currentThreadname = threading.currentThread() 
       print "running in ", currentThreadname 

thread = myThread(1,"mythrd") 
thread.run() 

run.py start.py से केवल एक पंक्ति अलग है।
अब दो बार के लिए run.py शुरू करें।

python run.py 
running in <_MainThread(MainThread, started 139854546364160)> 
python run.py 
running in <_MainThread(MainThread, started 139854546364160)> 

startandrun.py कोड नीचे जैसा है।

class myThread(threading.Thread): 
    def __init__(self, threadID, name): 
     threading.Thread.__init__(self) 
     self.threadID = threadID 
     self.name = name 

    def run(self): 
     currentThreadname = threading.currentThread() 
     print "running in ", currentThreadname 

thread = myThread(1,"mythrd") 
thread.start() 
thread.run() 

अब दो बार के लिए startandrun.py शुरू करें।

python startandrun.py 
running in <myThread(mythrd, started 140317119899392)> 
running in <_MainThread(MainThread, started 140317144454912)> 
python startandrun.py 
running in running in <_MainThread(MainThread, started 139980210505472)> 
<myThread(mythrd, started 139980185949952)> 

JohanL के रूप में कहते हैं:
जब दो अलग-अलग धागे चल रहा है, सभी दांव बंद कर रहे हैं के रूप में जो पहले निष्पादित करेंगे।
आप मूल रूप से ऑपरेटिंग सिस्टम में शेड्यूलिंग छोड़ रहे हैं। startandrun.py निष्पादित करने के लिए पहली बार, thread.start()thread.run() से पहले मार डाला गया था, यह उत्पादन में परिणाम:

running in <myThread(mythrd, started 140317119899392)> 
running in <_MainThread(MainThread, started 140317144454912)> 

startandrun.py निष्पादित करने के लिए दूसरी बार, thread.start()thread.run() के बाद मार डाला गया था, क्यों उत्पादन में परिणाम नहीं :

running in <_MainThread(MainThread, started 140317144454912)> 
running in <myThread(mythrd, started 140317119899392)> 

बजाय

running in running in <_MainThread(MainThread, started 139980210505472)> 
<myThread(mythrd, started 139980185949952)> 

Answer 1

यह क्या हो रहा है, क्योंकि जिस तरह से आप मूल्यों प्रिंट कर रहे हैं:

print "running in ", currentThreadname 

एक अल्पविराम जोड़ने के समान है:

print 'running in ' # without new line at the end 
print currentThreadname 

और दो कार्यों के बाद से यहां एक ही समय में चल रहे हैं आदेश कैसे निष्पादित किया जाता है:

print 'running in ' # without new line FUNCTION #1 
print 'running in ' # without new line FUNCTION #2 
print currentThreadName # with new line at the end FUNCTION #1 
print currentThreadName # with new line at the end FUNCTION #2 

कॉमा के बिना एक प्रिंट स्टेटमेंट का उपयोग करने का प्रयास करें समझते हैं कि यह कैसे किया जाना चाहिए:

def run(self): 
    currentThreadname = threading.currentThread() 
    print "running in {}".format(currentThreadname) 

यह सामान्य रूप से व्यवहार करेंगे लेकिन जब से दो कार्य एक ही समय में प्रिंट कर रहे हैं, तो आप निम्न उत्पादन प्राप्त कर सकते हैं: साबित होता है कि यह काम करेगा

running in <myThread(mythrd, started 10716)>running in <_MainThread(MainThread, started 12132)> 

तो आप time.sleep() का उपयोग कर दो कॉल के बीच में देरी का उपयोग कर सकते हैं:

import threading 
import time 

class myThread(threading.Thread): 
    def __init__(self, threadID, name): 
     threading.Thread.__init__(self) 
     self.threadID = threadID 
     self.name = name 

    def run(self): 
     currentThreadname = threading.currentThread() 
     print "running in {}".format(currentThreadname) 

thread = myThread(1,"mythrd") 
thread.start() 
time.sleep(0.1) 
thread.run() 

अब आप देख सकते हैं कि आप अपने वांछित उत्पादन मिलता है क्योंकि प्रत्येक कार्य एक टिम प्रिंट कर रहा है कॉल के बीच में एक 0.1 सेकंड देरी के साथ ई:

running in <myThread(mythrd, started 5600)> 
running in <_MainThread(MainThread, started 7716)> 

संपादित करें:

आपका मुद्दा ठीक है तुम क्यों इस्तेमाल करना चाहिए multithreading के बजाय एक ही धागे में दो बार चल रहा है। जब आप मल्टीथ्रेडिंग का उपयोग करते हैं तो आप thread.join() का उपयोग कर सकते हैं जो थ्रेड को समाप्त करने के लिए प्रतीक्षा करेगा और फिर कोड जारी रखेगा, या आप threading.lock() का उपयोग कर सकते हैं ताकि आप अपना कोड जारी रख सकें लेकिन एक समय में एक थ्रेड द्वारा उपयोग किए जाने वाले फ़ंक्शन को लॉक कर सकें। यहाँ कुछ उदाहरण हैं:

thread.join():

thread = myThread(1, "mythrd") 
thread2 = myThread(2, "thrd2") 
thread.start() 
thread.join() # code will stop here and wait for thread to finish then continue 
thread2.run() 

threading.lock():

.... 
    def run(self): 
     with lock: # if one thread uses this lock the other threads have to wait 
      currentThreadname = threading.currentThread() 
      print "running in ", currentThreadname 

thread = myThread(1, "mythrd") 
thread2 = myThread(2, "thrd2") 
lock = threading.Lock() 
thread.start() 
thread2.run() 
# code keeps running even if there are threads waiting for the lock 

Answer 2

कौन-सा संस्करण अजगर wer क्या आप उपयोग कर रहे हैं? पायथन 2 में, "प्रिंट" थ्रेड सुरक्षित नहीं है। कृपया http://tech.queryhome.com/54593/is-print-thread-safe-in-python-2-6-2-7 देखें।

यदि धागे "प्रिंट" के दौरान स्विच करते हैं, तो आउटपुट मिश्रित होते हैं, जैसा आपने देखा था।

Answer 3

तो, आप चाहते हैं कि आप अपने धागे को सिंक्रनाइज़ करें। इसे आसानी से का उपयोग करके() थ्रेडिंग लाइब्रेरी में फ़ंक्शन का उपयोग करके आसानी से किया जा सकता है।

आप इस

class myThread(threading.Thread): 
    def __init__(self, threadID, name): 
     threading.Thread.__init__(self) 
     self.threadID = threadID 
     self.name = name 

    def run(self): 
     currentThreadname = threading.currentThread() 
     print "running in ", currentThreadname 

thread = myThread(1,"mythrd") 
t1 = thread.start() 
t1.join() 
t2 = thread.run() 
t2.join() 

तुम भी बेहतर कारणों के लिए सेमाफोर और लॉक का उपयोग कर सकते की तरह कुछ कर सकते हैं। अधिक जानकारी के लिए दस्तावेज़ देखें।

Answer 4

शायद आपको समझ में नहीं आता कि थ्रेड कैसे काम कर रहे हैं। this ध्यान से पढ़ें।

मैं आपको futures लाइब्रेरी से ThreadPoolExecutor का उपयोग करने का सुझाव देता हूं।