如何開啓多進程及多進程相關經常使用方法

什麼是進程

進程（Process）是計算機中的程序關於某數據集合上的一次運行活動，是系統進行資源分配和調度的基本單位，是操做系統結構的基礎。

2 進程的兩種開啓方法
  (1) p = Process(target=None,args(,))
  (2) 自定義類，繼承Process父類

3 進程的經常使用方法
  （1） start()  開啓一個子進程
  （2） join()   異步變同步（就是讓父進程停留在join這句話，等待子進程執行結束，父進程再繼續執行）
  （3） is_alive() 判斷進程是否活着
  （4） terminate()   殺死進程
4 進程的經常使用屬性
   （1） p.name =    給p進程一個名字
   （2） p.pid       返回p進程的pid
   （3） p.daemon = True   將p進程設置爲守護進程。（True爲守護進程，False爲普通進程）

       守護進程的兩個特色：
          隨着父進程的代碼執行完畢才結束
          守護進程不能建立子進程
　　　　　　守護進程必需要在start以前設置

並行:  指二者同時執行，好比有兩條車道，在某一個時間點，兩條車道上都有車在跑；（資源夠用，好比三個線程，四核的CPU ）

併發: 併發是指資源有限的狀況下，二者交替輪流使用資源，好比只有一條車道(單核CPU資源)，

　　   那麼就是A車先走，在某個時刻A車退出把道路讓給B走，B走完繼續給A ，交替使用，目的是提升效率。

 

同步: 所謂同步就是一個任務的完成須要依賴另一個任務時，只有等待被依賴的任務完成後，依賴的任務才能算完成，

　　 這是一種可靠的任務序列。要麼成功都成功，失敗都失敗，兩個任務的狀態能夠保持一致。

異步: 不須要等待被依賴的任務完成，只是通知被依賴的任務要完成什麼工做，依賴的任務也當即執行，

　　 只要本身完成了整個任務就算完成了。至於被依賴的任務最終是否真正完成，依賴它的任務沒法肯定，因此它是不可靠的任務序列。

 

阻塞, 非阻塞:  阻塞和非阻塞這兩個概念與程序（線程）等待消息通知(無所謂同步或者異步)時的狀態有關。也就是說阻塞與非阻塞主要是程序（線程）等待消息通知時的狀態角度來講的

 

開啓子進程的方式:

# 先導入 multiprocessing中的Process
from multiprocessing import Process
import time
import os

def func1():
    time.sleep(1)
    # os.getpid() 獲取當前進程的pid,os.getppid()獲取當前進程的父進程的pid
    print('子進程:子進程的pid是%s,子進程的父進程是%s' % (os.getpid(),os.getppid()))

if __name__ == '__main__':
    p = Process(target=func1(),args=(1,))
    p.start()
    print('這裏是父進程:父進程的pid是%s,父進程的父進程是%s' % (os.getpid(),os.getppid()))

 

進程的經常使用方法:  terminate, is_alive

from multiprocessing import Process
import time

# p.is_alive() 判斷進程是否存活  
# p.terminate() 殺死p程序,讓解釋器告訴操做系統銷燬p進程

def func1():
    time.sleep(1)
    print('子進程')


if __name__ == '__main__':
    p = Process(target=func1(),)
    p.start()
    print('子進程狀態狀態:', p.is_alive())
    p.terminate() # 殺死p進程,讓解釋器告訴操做系統銷燬p進程
    time.sleep(2)
    print('子進程狀態狀態:',p.is_alive())

 

 進程的經常使用方法:  join方法 : 是讓主進程等待子進程執行完

from multiprocessing import Process
import time

def func():
    for i in range(500):
        time.sleep(0.01)
        print('兒子在這裏')

if __name__ == '__main__':
    p = Process(target=func)
    p.start()
    p.join()# 是讓主進程等待子進程執行完。  現象：主進程執行到這句話，主進程阻塞住，等待子進程執行
    # time.sleep(1)
    for i in range(100):
        time.sleep(0.01)
        print('爸爸在這裏')

# 開啓一個正常的子進程，父進程會等待子進程結束後，父進程也就是程序才結束
# p.join()# 是讓主進程等待子進程執行完。  現象：主進程執行到這句話，主進程阻塞住，等待子進程執行
# 如何把父進程和子進程之間的關係變爲同步或者異步？
# 父進程執行join，就會變成同步，不執行join，父進程和子進程就是異步的關係
# join必須放在start()後邊

 

進程經常使用屬性: p.name p.pid p.daemon(守護進程)

 

from multiprocessing import Process
import os

def func():
    print('這裏是子進程,子進程的pid是%s' % (os.getpid))

if __name__ == '__main__':
    p = Process(target=func())
    p.start()
    p.name = 'ben'
    print('子進程的名字爲%s' % p.name)
    print('子進程的pid爲%s' % p.pid)
    print('子進程是否爲守護進程,%s' % p.daemon)

 

 

多進程之間沒法共享內存

from multiprocessing import Process
def func(i):
    print('我是%s'%i)
    # global n
    print(n)


if __name__ == '__main__':
    n = 100
    addr = ['河南的','山東的','遼寧的','湖南的']
    for i in addr:
        p = Process(target=func,args=(i,))
        p.start()