線程與裝飾

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. 據我瞭解，方法1和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

也許信號燈可以在裝修幫，這樣的事情 - 計算階乘號碼從1到1000 ：

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)