python3的使用

下面分別是python 進一步封裝好的線程池 和進程池

from concurrent.futures import  ThreadPoolExecutor
from concurrent.futures import  ProcessPoolExecutor

import time

def task(arg):
    print(arg)
    time.sleep(1)
    
pool= ProcessPoolExecutor
pool= ThreadPoolExecutor

for i in range(50):
    pool.submit(task,i)

一、再次了解相同區別

進程：
優點：同時利用多個cpu,能夠同時進行多個操作
缺點：耗費資源（因為給開辟內存空間）
線程：
優點：共享內存，io操作的時候，創作并發操作
缺點：搶占資源
進程：不是越多越好，cpu個數等于進程個數
線程：也不是越多越好，具體案例具體分析，請求上下文切換耗時，計算機中執行任務的最小單元是線程

二、目的

進程和線程目的：提高效率
Io操作不利用cpu：
IO密集型（不使用cpu）：多線程----GIL全局解釋器鎖
計算密集型（使用cpu）：多進程

三、進程

1.創建進程

from multiprocessing import Process

def test(n):
    print(n)

if __name__ == '__main__':

    for i in range(4):
        p = Process(target=test,args=(i,))
        p.start()

2.進程中的join等待，等待進程結束運行下一個進程
未使用join運行結果

from multiprocessing import Process
import time
def test(n):
    print(n)
    time.sleep(2)
if __name__ == '__main__':

    for i in range(4):
        p = Process(target=test,args=(i,))
        p.start()

    print("end")
》》》
end
0
3
1
2

使用join

from multiprocessing import Process
import time
def test(n):
    print(n)
    time.sleep(2)
if __name__ == '__main__':
    for i in range(4):
        p = Process(target=test,args=(i,))
        p.start()
        #等待的意思
        p.join()

    print("end")、
》》》
0
1
2
3
end

3.deamon 等同線程中setdeamon線程守護

from multiprocessing import Process
import time
def test(n):
    print(n)
    time.sleep(2)
if __name__ == '__main__':

    for i in range(4):
        p = Process(target=test,args=(i,))
        # 進程守護，結束都結束
        p.daemon = True
        p.start()


    print("end")

四、通過代碼理解進程

進程可以理解成是對主進程的copy~，也就是如果線程對一個列表操作的話，實際上是對同一個列表操作，進程操作的就是復制出來的列表

from multiprocessing import Process
import time
a_list = []
def test(n):
    a_list.append(n)
    print(a_list)

if __name__ == '__main__':
    for i in range(4):
        p = Process(target=test,args=(i,))
        p.start()


    print("end")
>>>
end
[0]
[1] 
[3]
[2]

五、進程池

p = Pool(5)
p.apply          每一個任務都是排隊進行的，相當于自身包含個join方法
p.apply_async   每一個任務都是并發進行的，可以設置回調函數，deamon=True，等待線程

進程和線程其實還有一點區別，就是如果主線程執行完畢，其實子線程還是在運行的，除非設置了保護線程。單進程不是這樣，如果主進程結束了，子進程也不會執行

from multiprocessing import Pool
import time
def f1(a):
    time.sleep(1)
    print(a)
if __name__ == '__main__':
    pool = Pool(5)
    for i in range(10):
        pool.apply_async(func=f1,args=(i,))

上面的代碼運行結果沒有的，因為主進程結束了，子進程還在sleep等待，主進程銷毀了子進程也跟著銷毀了
有兩種辦法解決，方法一主進程的結束時間大于子進程

from multiprocessing import Pool
import time
def f1(a):
    time.sleep(1)
    print(a)


if __name__ == '__main__':
    pool = Pool(5)
    for i in range(10):
        pool.apply_async(func=f1,args=(i,))

    time.sleep(2.5)

第二種使用join進程等待

from multiprocessing import Pool
import time
def f1(a):
    time.sleep(1)
    print(a)


if __name__ == '__main__':
    pool = Pool(5)
    for i in range(10):
        pool.apply_async(func=f1,args=(i,))
    pool.close()
    pool.join()

上面的代碼運行的時候五個為一個結果展示