अजगर में धागे का निर्माण

Question

मेरे पास एक स्क्रिप्ट है और मैं चाहता हूं कि एक फंक्शन दूसरे की तरह ही चले।

उदाहरण कोड मैंने देखा है:

import threading

def MyThread (threading.thread):
    # doing something........

def MyThread2 (threading.thread):
    # doing something........

MyThread().start()
MyThread2().start()

मुझे यह काम करने में परेशानी हो रही है। मैं एक वर्ग के बजाय एक थ्रेडेड फ़ंक्शन का उपयोग करके इसे प्राप्त करना पसंद करूंगा।

यह वर्किंग स्क्रिप्ट है:

from threading import Thread

class myClass():

    def help(self):
        os.system('./ssh.py')

    def nope(self):
        a = [1,2,3,4,5,6,67,78]
        for i in a:
            print i
            sleep(1)


if __name__ == "__main__":
    Yep = myClass()
    thread = Thread(target = Yep.help)
    thread2 = Thread(target = Yep.nope)
    thread.start()
    thread2.start()
    thread.join()
    print 'Finished'

Answer 1

Threadइस काम को करने के लिए आपको एक उपवर्ग का उपयोग करने की आवश्यकता नहीं है - साधारण उदाहरण पर एक नज़र डालें जो मैं नीचे पोस्ट कर रहा हूं कि कैसे देखें:

from threading import Thread
from time import sleep

def threaded_function(arg):
    for i in range(arg):
        print("running")
        sleep(1)


if __name__ == "__main__":
    thread = Thread(target = threaded_function, args = (10, ))
    thread.start()
    thread.join()
    print("thread finished...exiting")

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

Comments

मैंने यह कोशिश की है। मैंने ऊपर स्क्रिप्ट लिखी है। क्या आप मुझे बता सकते हैं कि पहले के साथ-साथ चल रहे दूसरे फ़ंक्शन को कैसे प्राप्त करें। धन्यवाद

— chrissygormley

@chrissygormley: ज्वाइन () पहले थ्रेड खत्म होने तक ब्लॉक।

— फोगबर्ड

@chrissygormley: जैसा कि उल्लेख किया गया है, तब तक ब्लॉक ज्वाइन करें जब तक कि आप जिस फिनिश में शामिल नहीं हो रहे हैं, उसके साथ जुड़ जाएं, इसलिए अपने दूसरे फंक्शन के साथ एक दूसरे थ्रेड को दो फंक्शन्स को साथ-साथ चलाने के लिए लक्ष्य के रूप में शुरू करें, फिर वैकल्पिक रूप से उनमें से एक में शामिल हों आप बस तब तक इंतजार करना चाहते हैं जब तक वे पूरा नहीं हो जाता।

— jkp

मैं वैसे exitingही पढ़ता रहा exciting, जो मुझे लगा कि वैसे भी अधिक उपयुक्त है।

— रॉबर्ट्स

Answer 2

आपके कोड में कुछ समस्याएं हैं:

def MyThread ( threading.thread ):

• आप एक फ़ंक्शन के साथ उप-वर्ग नहीं कर सकते हैं; केवल एक वर्ग के साथ
• यदि आप एक उपवर्ग का उपयोग करने जा रहे हैं, तो आप थ्रेडिंग करना चाहते हैं

यदि आप वास्तव में केवल कार्यों के साथ ऐसा करना चाहते हैं, तो आपके पास दो विकल्प हैं:

सूत्रण के साथ:

import threading
def MyThread1():
    pass
def MyThread2():
    pass

t1 = threading.Thread(target=MyThread1, args=[])
t2 = threading.Thread(target=MyThread2, args=[])
t1.start()
t2.start()

धागे के साथ:

import thread
def MyThread1():
    pass
def MyThread2():
    pass

thread.start_new_thread(MyThread1, ())
thread.start_new_thread(MyThread2, ())

थ्रेड के लिए डॉक .start_new_thread

Comments

दूसरे तर्क के लिए टपल होना चाहिएthread.start_new_thread(function, args[, kwargs])

— venkatvb

Answer 3

मैंने एक और जुड़ने की कोशिश की (), और यह काम कर रहा है। यहाँ कोड है

from threading import Thread
from time import sleep

def function01(arg,name):
    for i in range(arg):
        print(name,'i---->',i,'\n')
        print (name,"arg---->",arg,'\n')
        sleep(1)

def test01():
    thread1 = Thread(target = function01, args = (10,'thread1', ))
    thread1.start()
    thread2 = Thread(target = function01, args = (10,'thread2', ))
    thread2.start()
    thread1.join()
    thread2.join()
    print ("thread finished...exiting")

test01()

Answer 4

आप सीधे एक फ़ंक्शन में पास करने के targetलिए Threadकंस्ट्रक्टर में तर्क का उपयोग कर सकते हैं जिसे इसके बजाय कहा जाता है run।

Answer 5

क्या आपने रन () विधि को ओवरराइड किया था? यदि आपने ओवरराइड किया है __init__, तो क्या आपने आधार को कॉल करना सुनिश्चित किया है threading.Thread.__init__()?

दो धागे शुरू करने के बाद, क्या मुख्य धागा अनिश्चित काल तक काम करना जारी रखता है / बच्चे के धागे पर ब्लॉक / जुड़ते हैं ताकि मुख्य धागा निष्पादन समाप्त न हो जाए इससे पहले कि बच्चे अपने कामों को पूरा करें?

और अंत में, क्या आपको कोई अपवाद नहीं मिल रहा है?

Comments

कोई अखंड अपवाद नहीं हैं और मुख्य धागा 30mins के लिए चलना चाहिए। मैंने ओवरराइड नहीं की __init__। क्या रन () की आवश्यकता है? धन्यवाद

— क्रिस्चोगर्मले

मुझे बस एहसास हुआ कि आपका उदाहरण है def MyThread ( threading.thread )... मैंने मान लिया कि वे वर्ग परिभाषाएं थीं। आप उपवर्ग threading.thread के लिए जा रहा है और साथ धागा वस्तु को प्रारंभ रहे हैं target=Noneया छोड़ targetआर्ग, तो रन के एक कार्यान्वयन () की आवश्यकता है। अन्यथा, यदि आप किसी अन्य थ्रेड में केवल एक साधारण कार्य चलाना चाहते हैं, तो jkp का उत्तर देखें।

— जेरेमी ब्राउन

Answer 6

पायथन 3 में समानांतर कार्यों को शुरू करने की सुविधा है । इससे हमारा काम आसान हो जाता है।

इसमें थ्रेड पूलिंग और प्रोसेस पूलिंग है ।

निम्नलिखित एक अंतर्दृष्टि देता है:

ThreadPoolExecutor उदाहरण

import concurrent.futures
import urllib.request

URLS = ['http://www.foxnews.com/',
        'http://www.cnn.com/',
        'http://europe.wsj.com/',
        'http://www.bbc.co.uk/',
        'http://some-made-up-domain.com/']

# Retrieve a single page and report the URL and contents
def load_url(url, timeout):
    with urllib.request.urlopen(url, timeout=timeout) as conn:
        return conn.read()

# We can use a with statement to ensure threads are cleaned up promptly
with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
    # Start the load operations and mark each future with its URL
    future_to_url = {executor.submit(load_url, url, 60): url for url in URLS}
    for future in concurrent.futures.as_completed(future_to_url):
        url = future_to_url[future]
        try:
            data = future.result()
        except Exception as exc:
            print('%r generated an exception: %s' % (url, exc))
        else:
            print('%r page is %d bytes' % (url, len(data)))

एक और उदाहरण

import concurrent.futures
import math

PRIMES = [
    112272535095293,
    112582705942171,
    112272535095293,
    115280095190773,
    115797848077099,
    1099726899285419]

def is_prime(n):
    if n % 2 == 0:
        return False

    sqrt_n = int(math.floor(math.sqrt(n)))
    for i in range(3, sqrt_n + 1, 2):
        if n % i == 0:
            return False
    return True

def main():
    with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
        for number, prime in zip(PRIMES, executor.map(is_prime, PRIMES)):
            print('%d is prime: %s' % (number, prime))

if __name__ == '__main__':
    main()