python類庫32[多進程同步Lock+Semaphore+Event]

同步的方法基本與多線程相同。

 

1) Lock

當多個進程需要訪問共享資源的時候，Lock可以用來避免訪問的沖突。

           import multiprocessing 
          
import sys 
          
 
          
def worker_with( 
          lock, f): 
          
    with  
          lock: 
          
        fs = open(f, 
          " 
          a+ 
          ") 
          
        fs.write( 
          ' 
          Lock acquired via with\n 
          ') 
          
        fs.close() 
          
         
          
def worker_no_with( 
          lock, f): 
          
     
          lock.acquire() 
          
     
          try: 
          
        fs = open(f, 
          " 
          a+ 
          ") 
          
        fs.write( 
          ' 
          Lock acquired directly\n 
          ') 
          
        fs.close() 
          
     
          finally: 
          
         
          lock.release() 
          
 
          
 
          if __name__ ==  
          " 
          __main__ 
          ": 
          
 
          
    f =  
          " 
          file.txt 
          " 
          
   
          
     
          lock = multiprocessing.Lock() 
          
    w = multiprocessing.Process(target=worker_with, args=( 
          lock, f)) 
          
    nw = multiprocessing.Process(target=worker_no_with, args=( 
          lock, f)) 
          
 
          
    w.start() 
          
    nw.start() 
          
 
          
    w.join() 
          
    nw.join() 
         

     

在上面的例子中，如果兩個進程沒有使用lock來同步,則他們對同一個文件的寫操作可能會出現混亂。

 

2）Semaphore

Semaphore用來控制對共享資源的訪問數量，例如池的最大連接數。

 
           import multiprocessing 
           
 
           import time  
           
 
           
 
           def worker(s,i): 
           
    s.acquire() 
           
     
           print(multiprocessing.current_process().name +  
           " 
            acquire 
           ") 
           
    time.sleep(i) 
           
     
           print(multiprocessing.current_process().name +  
           " 
            release 
           ") 
           
    s.release() 
           
 
           
 
           if  
           __name__ ==  
           " 
           __main__ 
           ": 
           
   
           
    s = multiprocessing.Semaphore(2) 
           
     
           for i  
           in range(5): 
           
        p = multiprocessing.Process(target=worker, args=(s,i*2)) 
           
        p.start() 
          

 

上面的實例中使用semaphore限制了最多有2個進程同時執行。

 

3）Event

Event用來實現進程間同步通信。

 
           import multiprocessing 
           
 
           import time 
           
 
           
 
           def wait_for_event(e): 
           
     
           """ 
           Wait for the event to be set before doing anything 
           """ 
           
     
           print ( 
           ' 
           wait_for_event: starting 
           ') 
           
    e.wait() 
           
     
           print ( 
           ' 
           wait_for_event: e.is_set()-> 
           ' + str(e.is_set())) 
           
 
           
 
           def wait_for_event_timeout(e, t): 
           
     
           """ 
           Wait t seconds and then timeout 
           """ 
           
     
           print ( 
           ' 
           wait_for_event_timeout: starting 
           ') 
           
    e.wait(t) 
           
     
           print ( 
           ' 
           wait_for_event_timeout: e.is_set()-> 
           ' + str(e.is_set())) 
           
 
           
 
           
 
           if  
           __name__ ==  
           ' 
           __main__ 
           ': 
           
    e = multiprocessing.Event() 
           
    w1 = multiprocessing.Process(name= 
           ' 
           block 
           ',  
           
                                 target=wait_for_event, 
           
                                 args=(e,)) 
           
    w1.start() 
           
 
           
    w2 = multiprocessing.Process(name= 
           ' 
           non-block 
           ',  
           
                                 target=wait_for_event_timeout,  
           
                                 args=(e, 2)) 
           
    w2.start() 
           
 
           
    time.sleep(3) 
           
    e.set() 
           
     
           print ( 
           ' 
           main: event is set 
           ') 
           
     
           
 
           # 
           the output is: 
           
# 
           wait_for_event_timeout: starting 
           
# 
           wait_for_event: starting 
           
# 
           wait_for_event_timeout: e.is_set()->False 
           
# 
           main: event is set 
           
# 
           wait_for_event: e.is_set()->True 
           
 
          

 

參考：http://www.doughellmann.com/PyMOTW/multiprocessing/communication.html 

 

完！