सजावट के साथ थ्रेड

Question

मैं अपने आवेदन में थ्रेडिंग (सजावटी का उपयोग करने के साथ) को लागू करने की कोशिश कर रहा हूं, लेकिन ताले और प्रबंधन धागे के बारे में कुछ चीजें समझ नहीं पा रहा हूं।

import threading 

def run_in_thread(fn): 
    def run(*k, **kw): 
     t = threading.Thread(target=fn, args=k, kwargs=kw) 
     t.start() 
    return run 

class A: 
    @run_in_thread 
    def method1(self): 
     for x in range(10000): 
      print x 


    @run_in_thread 
    def method2(self): 
     for y in list('wlkefjwfejwiefwhfwfkjshkjadgfjhkewgfjwjefjwe'): 
      print y 

    def stop_thread(self): 
     pass 

c = A() 
c.method1() 
c.method2() 

1. के रूप में मैं समझता हूँ, Method1 और Method2 सिंक्रनाइज़ नहीं कर रहे हैं, लेकिन उस सामान का समन्वयन करने ताले की मदद से लागू करने। मैं अपने सजावटी-समारोह में ताले कैसे जोड़ सकता हूं?

2. सजावटी का उपयोग करके लंबे धागे को रोकने के लिए मुझे विधि का एहसास कैसे हो सकता है?

Answer 1

def run_in_thread(fn): 
    def run(*k, **kw): 
     t = threading.Thread(target=fn, args=k, kwargs=kw) 
     t.start() 
     return t # <-- this is new! 
    return run 

का उपयोग करके आप धागा पर बेहतर नियंत्रण के लिए अनुमति देता है: आप कर सकते हैं तो

c = A() 
t1 = c.method1() 
t1.join() # wait for it to finish 
t2 = c.method2() 
# ... 

Answer 2

1. आप दो धागे आप बस सजाया काम करता है, नहीं सज्जाकार खुद को अंदर ताले जोड़ने की जरूरत है सिंक्रनाइज़ करने के लिए चाहते हैं।

2. सीधे थ्रेड को रोकने का कोई आसान तरीका नहीं है, थ्रेड को सिग्नल करने के लिए किसी ईवेंट का उपयोग करने का एकमात्र तरीका यह है कि इसे बाहर निकलना चाहिए।

थ्रेडिंग सजावटी के लिए आप pebble पर एक नज़र डाल सकते हैं।

Answer 3

शायद Semaphores सज्जाकार में मदद कर सकता है, कुछ इस तरह - 1000 1 से भाज्य संख्या की गणना :

import threading 

from functools import wraps 
from math import factorial 


DIC = {} 

def limit(number): 
    ''' This decorator limits the number of simultaneous Threads 
    ''' 
    sem = threading.Semaphore(number) 
    def wrapper(func): 
     @wraps(func) 
     def wrapped(*args): 
      with sem: 
       return func(*args) 
     return wrapped 
    return wrapper 

def async(f): 
    ''' This decorator executes a function in a Thread''' 
    @wraps(f) 
    def wrapper(*args, **kwargs): 
     thr = threading.Thread(target=f, args=args, kwargs=kwargs) 
     thr.start() 
    return wrapper 

@limit(10)  # Always use @limit as the outter decorator 
@async 
def calcula_fatorial(number): 
    DIC.update({number: factorial(number)}) 

@limit(10) 
def main(lista): 
    for elem in lista: 
     calcula_fatorial(elem) 


if __name__ == '__main__': 
    from pprint import pprint 
    main(range(1000)) 
    pprint(DIC)