主要內容:

1 名詞解釋

並行 : 即兩件事情或多件事情,在同一時間點同時執行.是從微觀上，也就是在一個精確的時間片刻，有不同的程序在執行，這就要求必須有多個處理器

並發 : 即兩件事情或多件事情在同一時間段交替進行. 是從宏觀上，在一個時間段上可以看出是同時執行的，比如一個服務器同時處理多個session。

同步 : 所謂同步就是一個任務的完成需要依賴另外一個任務時，只有等待被依賴的任務完成後，依賴的任務才能算完成，這是一種可靠的任務序列。要麽成功都成功，失敗都失敗，兩個任務的狀態可以保持一致。

異步 : 所謂異步是不需要等待被依賴的任務完成，只是通知被依賴的任務要完成什麽工作，依賴的任務也立即執行，只要自己完成了整個任務就算完成了

阻塞 :

非阻塞 :

2 . 開啟進程兩種方式

　　1) 第一種

from multiprocessing import Process
import os
import time
def func(i):
    time.sleep(0.2)
    print(‘這是子進程%s,pid為%s ,其父進程的pid為%s‘ % (i, os.getpid(), os.getppid()))
# os.getpid(), 獲得當前進程的pid,
# os.getppid(),獲得當前進程的父進程的pid
 

if __name__ == ‘__main__‘:
    for i in range(2):
        p = Process(target=func, args=(i,))   #實例化一個進程對象
        #target:子進程要執行的任務,args:父進程要給子進程傳遞的參數,必須是元祖形式.
        p.start()                            #開啟一個進程.
        time.sleep(0.2)
    print(‘這是父進程, pid為%s, 其父進程的pid為%s‘ % (os.getpid(), os.getppid()))

　　2) 繼承

from multiprocessing import Process
import time
import os
class Myprocess(Process):
    def __init__(self):
        super(Myprocess, self).__init__()
    def run(self):
        print(‘在類中創建子進程‘)
if __name__ == ‘__main__‘:
    p = Myprocess()
    p.start()       #是指解釋器告訴操作系統, 去幫我開啟一個進程, 就緒狀態
    p.run()         # 解釋器告訴操作系統,馬上幫我執行這個過程.   執行狀態

　　 帶名字的

from multiprocessing import Process
import time
import os
class Myprocess(Process):
    def __init__(self, name):
        self.name = name
        super(Myprocess, self).__init__(name = name)   # 如果不寫在執行父類中的__init是name會被覆蓋.
    def run(self):
        print(‘這是以類的方式開啟的子進程, 名字為%s‘ % self.name)
if __name__ == ‘__main__‘:
    p = Myprocess(‘alex‘)
    p.start()       #是指解釋器告訴操作系統, 去幫我開啟一個進程, 就緒狀態.
    # p.run()       # 解釋器告訴操作系統立即去開啟一個進程, 執行狀態.

3 . 進程的常用方法:

　　1) start 和join

　　　　join : 是讓主進程等待子進程執行完再執行

from multiprocessing import Process
import os
import time
def func():
    for i in range(100):
        time.sleep(0.1)
        print(‘這是子進程‘)
if __name__ == ‘__main__‘:
    p = Process(target=func)   #子進程要執行的任務
    p.start()
    # p.join()                   #是讓主進程等待子進程執行完, 現象 : 主進程走到這句話, 主進程阻塞住, 等待子進程執行完.
    for i in range(100):
        time.sleep(0.1)
        print(‘這是父進程‘)
# 開啟一個正常的子進程，父進程會等待子進程結束後，父進程也就是程序才結束
# p.join()# 是讓主進程等待子進程執行完。  現象：主進程執行到這句話，主進程阻塞住，等待子進程執行
# 如何把父進程和子進程之間的關系變為同步或者異步？
# 父進程執行join，就會變成同步，不執行join，父進程和子進程就是異步的關系
# join必須放在start()後邊

　　2) is_alive 和terminate

def func():
    time.sleep(1)
if __name__ == ‘__main__‘:
    p = Process(target=func,)
    p.start()
    p.terminate()# 殺死p進程,讓解釋器告訴操作系統，請殺掉p進程。
    print(‘子進程是否還活著？‘, p.is_alive())
    time.sleep(0.002)
    print(‘子進程是否還活著？‘, p.is_alive())
    # 返回一個bool值，如果返回True，代表進程還活著,如果返回False，代表子進程死了
# p.is_alive() 判斷p進程是否還活著
# p.terminate() 殺死p進程

4 . 進程的常用屬性:

　　1) name 和 pid

from multiprocessing import Process
import time
import os
def func():
    print(‘這是子進程, pid為%s‘ % os.getpid())
if __name__ == ‘__main__‘:
    p = Process(target=func)
    p.start()
    p.name = ‘alex‘
    print(‘可以查看子進程的pid‘,p.pid)
    print(‘可以查看子進程的名字‘, p.name)
    print(‘子進程是不是守護進程‘, p.daemon)   false

　　2 ) 守護進程

　　　　特點 : 將進程設置為守護進程 , 必須在start之前 daemon = false

　　　　　　　守護進程會隨著主進程的結束而結束

　　　　　　　守護進程不能有子進程.

　　　　**守護進程會隨著主進程的結束而結束

from multiprocessing import Process
import time
def func():
    time.sleep(3.1)
    print(‘this is son process‘)
if __name__ == ‘__main__‘:
    p = Process(target=func)
    p.daemon = True       #必須在start之前設置
    p.start()
    time.sleep(3)
    print(‘this is parent process‘)
#守護進程會隨著主進程的結束而結束.

　 **守護進程不能有子進程

from multiprocessing import Process
import time
def func1():
    print(‘這裏是孫子‘)
def func():
    p = Process(target=func1)
    p.start()
    time.sleep(5)
    print(‘這裏是兒子哦‘)
if __name__ == ‘__main__‘:
    p = Process(target=func)
    p.daemon = True # 將p進程設置為守護進程,必須要在start之前設置
    p.start()
    time.sleep(1)
    print(‘這是爸爸‘)
# 守護進程：不允許開啟子進程

35 並行/發 同/異步 非/ 阻塞 進程的兩種開啟方式, 進程的常用方法及屬性