Python學習筆記|Python之程式

1.單程式

	def work_1(f,n):
	    print('work_1 start')
	    for i in range(n):
	        with open(f,'a') as fs:
	            fs.write('i love pyhton \n')
	            time.sleep(1)
	    print('work_1 end')
	
	
	def work_2(f,n):
	    print('work_2 start')
	    for i in range(n):
	        with open(f,'a') as fs:
	            fs.write('i love java \n')
	            time.sleep(1)
	    print('work_2 end')
	
	if __name__ == '__main__':
	    work_1('file.txt',3)
	    work_2('file.txt',3)

2.多程式

• 建立程式

匯入import multiprocessing，使用Process方法建立程式，具體如下：

multiprocessing.Process(target=要執行操作,args = (要操作的函式的引數))

• 啟動程式

呼叫start方法

p1.start()

完成的程式如下：

	def work_1(f,n):
	    print('work_1 start')
	    for i in range(n):
	        with open(f,'a') as fs:
	            fs.write('i love pyhton \n')
	            time.sleep(1)
	    print('work_1 end')
	
	
	def work_2(f,n):
	    print('work_2 start')
	    for i in range(n):
	        with open(f,'a') as fs:
	            fs.write('i love java \n')
	            time.sleep(1)
	    print('work_2 end')
	
	if __name__ == '__main__':
	    p1 = multiprocessing.Process(target=work_1,args = ('file.txt',3))
	    p2 = multiprocessing.Process(target=work_2, args=('file.txt', 3))
	
	    p1.start()
	    p2.start()

3.程式鎖

• 程式鎖

使用multiprocessing.Lock()建立程式鎖

lock=multiprocessing.Lock()

• 獲取程式鎖

使用acquire()獲取程式鎖

lock.acquire()

• 釋放程式鎖

使用release()獲取程式鎖

lock.release()

完整的程式如下

	def work_1(f,n,lock):
	    print('work_1 start')
	    lock.acquire()
	    for i in range(n):
	        with open(f,'a') as fs:
	            fs.write('i love pyhton \n')
	            time.sleep(1)
	    print('work_1 end')
	    lock.release()
	
	def work_2(f,n,lock):
	    print('work_2 start')
	    lock.acquire()
	    for i in range(n):
	        with open(f,'a') as fs:
	            fs.write('i love java \n')
	            time.sleep(1)
	    print('work_2 end')
	    lock.release()
	
	if __name__ == '__main__':
	    lock=multiprocessing.Lock()
	    p1 = multiprocessing.Process(target=work_1,args = ('file.txt',3,lock))
	    p2 = multiprocessing.Process(target=work_2, args=('file.txt', 3,lock))
	
	    p1.start()
	    p2.start()

• 加程式鎖後變成了與單程式一樣

4.程式池

• 建立程式池

使用multiprocessing.Pool(程式池個數)建立程式池

pool=multiprocessing.Pool(2)

• 使用程式池

使用apply_async使用程式池

pool.apply_async(work,args=(i，))

使用apply使用程式池

pool.apply(work,args=(i，))

• 結束程式池工作

比較危險,不要輕易用,直接殺死程式池

pool.terminate()

• 阻塞主程式

join阻塞主程式,當子程式執行完畢的時候會繼續往後執行,使用join必須在程式池使用terminate或者close

pool.join()

完成流程如下:

	def  work(n):
	   print('run work (%s) ,work id %s'%(n,os.getpid()))
	   time.sleep(5)
	   print('work (%s) stop ,work id %s'%(n,os.getpid()))
	
	
	if __name__=='__main__':
	   print('Parent process %s.' % os.getpid())
	  
	   p = multiprocessing.Pool(3)
	   for i in range(5):
	       
	        p.apply_async(work, args=(i,))#同時執行3個，釋放了其中一個在執行其他剩餘
	        #p.apply(work, args=(i,))#一個一個執行，執行完一個才能執行下一個
	   p.close()
	   p.join()

5.程式佇列

• 建立程式佇列

multiprocessing.Queue()

	#queue 跨程式通訊
	def put(q):
	   for value in ['A', 'B', 'C']:
	       print ('傳送 %s 到 queue...' % value)
	       q.put(value)  #通過put傳送
	       time.sleep(2)
	
	## 讀資料程式執行的程式碼:
	def get(q):
	   while True:
	       value = q.get(True) #接受佇列中的資料
	       print ('從 queue 接受 %s .' % value)
	
	if __name__=='__main__':
	   # 父程式建立Queue，並傳給各個子程式：
	   q = multiprocessing.Queue()
	   pw = multiprocessing.Process(target=put, args=(q,))
	   pr = multiprocessing.Process(target=get, args=(q,))
	   # 啟動子程式pw，寫入:
	   pw.start()
	   # 啟動子程式pr，讀取:
	   pr.start()
	   # 等待pw結束:
	   pw.join()
	   # pr程式裡是死迴圈，無法等待其結束，只能強行終止:
	   pr.terminate()

6.管道通訊

multiprocessing.Pipe()#雙向，即可發也可收
multiprocessing.Pipe(duplex=False) #左收右發

def put(p):
   for value in ['A', 'B', 'C']:
       print ('傳送 %s 到 pipe...' % value)
       p[1].send(value)
       time.sleep(2)

# 讀資料程式執行的程式碼:
def get(p):
   while True:
       value = p[0].recv()
       print ('從 pipe 接受 %s .' % value)

if __name__=='__main__':
   # 父程式建立Queue，並傳給各個子程式：
   # p = multiprocessing.Pipe()
   p = multiprocessing.Pipe(duplex=False) #左收右發
   pw = multiprocessing.Process(target=put, args=(p,))
   pr = multiprocessing.Process(target=get, args=(p,))
   # 啟動子程式pw，寫入:
   pw.start()
   # 啟動子程式pr，讀取:
   pr.start()
   # 等待pw結束:
   pw.join()
   # pr程式裡是死迴圈，無法等待其結束，只能強行終止:
   pr.terminate()