程序師世界是廣大編程愛好者互助、分享、學習的平台,程序師世界有你更精彩!
首頁
編程語言
C語言|JAVA編程
Python編程
網頁編程
ASP編程|PHP編程
JSP編程
數據庫知識
MYSQL數據庫|SqlServer數據庫
Oracle數據庫|DB2數據庫
您现在的位置: 程式師世界 >> 編程語言 >  >> 更多編程語言 >> Python

Python中的多進程(一看就懂)

編輯:Python

簡介:

什麼是多進程啊?
現在我們的計算機都是多個核的,通俗來說就是多個處理或者計算單元。為了加快運算和處理速度,我們可以將不同的任務交給多個核心進行同時處理,從而提高了運算速度和效率,多個核心同時運作就是多個進程同時進行,這就是多進程。

主要內容:

1.創建進程

創建進程和創建線程的方法基本一致,請看下面代碼。

# coding:utf-8
# 導入多進程的包,並重命名為mp
import multiprocessing as mp
# 主要工作
def p1():
print("zxy")
if __name__ == "__main__":
# 創建新進程
new_process = mp.Process(target=p1, name="p1")
# 啟動這個進程
new_process.start()
# 阻塞該進程
new_process.join()

控制台效果圖:

2.多進程中的Queue

為什麼要在多進程中使用queue呢?
因為多進程和多線程一樣,在工作函數中,無法通過return返回進程函數中的結果,所以使用queue進行存儲結果,要用的時候再進行取出。

# coding:utf-8
import time
import multiprocessing as mp
""" 使用多進程時,運行程序所用的時間 """
def job1(q):
res = 0
for i in range(100):
res += i + i**5 +i**8
time.sleep(0.1)
# 將結果放入隊列中
q.put(res)
def job2(q):
res = 0
for i in range(100):
res += i + i**5 +i**8
time.sleep(0.1)
q.put(res)
if __name__ == "__main__":
start_time = time.time()
# 創建隊列
q = mp.Queue()
# 創建進程1
process1 = mp.Process(target=job1, args=(q,))
# 創建進程2
process2 = mp.Process(target=job2, args=(q,))
process1.start()
process2.start()
# 通過隊列獲取值
res1 = q.get()
res2 = q.get()
print("res1為%d,res2為%d" % (res1, res2))
end_time = time.time()
print("整個過程所用時間為%s" %(end_time-start_time))

效果圖:

3.多進程與多線程的性能比較

接下來使用多進程、多線程、以及什麼都不用的普通方法進行處理,看看他們三種方法的效率如何?

# coding:utf-8
import multiprocessing as mp
import time
import threading as th
""" 多進程、多線程、普通方法的性能比較 """
# 多進程工作
def mp_job(res):
for i in range(10000000):
res += i**5 + i**6
print(res)
# 多線程工作
def mt_job(res):
for i in range(10000000):
res += i**5 + i**6
print(res)
# 普通方法工作
def normal_job(res):
for i in range(10000000):
res += i ** 5 + i ** 6
print(res)
if __name__ == "__main__":
mp_sum = 0
mp_start = time.time()
process1 =mp.Process(target=mp_job, args=(mp_sum, ))
process2 = mp.Process(target=mp_job, args=(mp_sum,))
process1.start()
process2.start()
process1.join()
process2.join()
mp_end = time.time()
print("多進程使用時間為", (mp_end-mp_start))
mt_start = time.time()
mt_sum = 0
thread1 = th.Thread(target=mt_job, args=(mt_sum, ))
thread2 = th.Thread(target=mt_job, args=(mt_sum, ))
thread1.start()
thread2.start()
thread1.join()
thread2.join()
mt_end = time.time()
print("多線程使用的時間是", (mt_end-mt_start))
normal_start = time.time()
normal_sum = 0
# 進行兩次
normal_job(normal_sum)
normal_job(normal_sum)
normal_end = time.time()
print("普通方法使用的時間是", (normal_end-normal_start))

效果圖:

實驗結果表明:多進程的效率確實高!!!

4.進程池pool

進程池是干什麼用的呢?
進程池就是python的多進程提供的一個池子,將所有的進程都放在這個池子裡面,讓計算機自己去使用進程池中的資源,從而多進程處理一些程序,進而提高工作效率。

(1)默認使用進程池中全部進程時
# coding:utf-8
import time
import multiprocessing as mp
""" 進程池pool的使用 """
def job(num):
time.sleep(1)
return num * num
if __name__ == "__main__":
start_time = time.time()
# 括號裡面不加參數時,默認使用進程池中所有進程
pool = mp.Pool()
res = pool.map(job, range(10))
print(res)
end_time = time.time()
print("運行時間為", (end_time-start_time))

效果圖:

(2)指定進程池中進程數時
# coding:utf-8
import time
import multiprocessing as mp
""" 進程池pool的使用 """
def job(num):
time.sleep(1)
return num * num
if __name__ == "__main__":
start_time = time.time()
# 括號裡面加參數時,指定兩個進程進行處理
pool = mp.Pool(processes=2)
res = pool.map(job, range(10))
print(res)
end_time = time.time()
print("運行時間為", (end_time-start_time))

效果圖:

(3)不使用多進程時
# coding:utf-8
import time
def job(res):
for i in range(10):
res.append(i*i)
time.sleep(1)
if __name__ == "__main__":
start_time = time.time()
res = []
job(res)
print(res)
end_time =time.time()
print("不使用進程池所用時間為", (end_time-start_time))

效果圖:

實驗結論:多進程處理事情,效率很高!!!核心越多,處理越快!

5.共享內存

一個核心,我們多線程處理時,可以使用全局變量來共享數據。但是多進程之間是不行的,那我們多進程之間應該如何共享數據呢?
那就得用到共享內存了!

# coding:utf-8
import multiprocessing as mp
""" 共享內存 """
if __name__ == "__main__":
# 第一個參數是數據類型的代碼,i代表整數類型
# 第二個參數是共享數據的值
v = mp.Value("i", 0)

6.進程鎖lock

進程鎖和線程鎖的用法基本一致。進程鎖的誕生是為了避免多進程之間搶占共享數據,進而造成多進程之間混亂修改共享內存的局面。

(1)不加鎖之前
# coding:utf-8
import multiprocessing as mp
import time
""" 進程中的鎖lock """
def job(v, num):
for i in range(10):
v.value += num
print(v.value)
time.sleep(0.2)
if __name__ == "__main__":
# 多進程中的共享內存
v = mp.Value("i", 0)
# 進程1讓共享變量每次加1
process1 = mp.Process(target=job, args=(v, 1))
# 進程2讓共享變量每次加3
process2 = mp.Process(target=job, args=(v, 3))
process1.start()
process2.start()

效果圖:

(2)加鎖之後
# coding:utf-8
import multiprocessing as mp
import time
""" 進程中的鎖lock """
def job(v, num, l):
# 加鎖
l.acquire()
for i in range(10):
v.value += num
print(v.value)
time.sleep(0.2)
# 解鎖
l.release()
if __name__ == "__main__":
# 創建進程鎖
l = mp.Lock()
# 多進程中的共享內存
v = mp.Value("i", 0)
process1 = mp.Process(target=job, args=(v, 1, l))
process2 = mp.Process(target=job, args=(v, 3, l))
process1.start()
process2.start()

效果圖:

附錄:本文參考來自——莫煩python,喜歡的話記得點贊+收藏+關注!如有錯誤,請大家及時指正!!!


  1. 上一篇文章:
  2. 下一篇文章:
Copyright © 程式師世界 All Rights Reserved