進程的兩種開啓方法,進程的經常使用方法,進程的經常使用屬性

　　進程: 資源分配單位.
　　進程的調度: 多個進程在操做系統控制下被 cpu執行, 去享用計算機資源.
　　　　先來先服務 算法
　　　　短做業優先 算法
　　　　時間片輪轉 算法
　　　　多級反饋隊列(包含上面三個的東西)

　　進程調度的過程是不可以隨意被程序影響的.  ps: 此時能夠更改代碼去配合 操做系統,

程序的並行與併發:
　　並行: 更快
　　併發: 宏觀上同時執行
　　進程一共有三個狀態: 就緒, 運行, 阻塞
　　同步, 異步 ps: 從宏觀角度來看.
　　堵塞, 非堵塞

　　PID: Process ID 進程ID
　　ppid: parent process id 父進程id

　　父進程: 負責回收一些子進程的資源.

　　Python來完成多進程: multiproess 包
　　　　建立進程: multiprocessing.Process 模塊
1, start() :不是運行一個程序, 而是調用操做系統的命令, 要開啓建立的子進程.
　　在不一樣的操做系統 使用Python, 都是調用操做系統的命令來啓動進程的, 且不一樣的操做系統操做Python都是不一樣的.
　　　　在windows 操做系統開啓了一個子進程, 第一步至關於import了父進程所在的文件.因此, 開啓子進程的時候, 必須把 建立子進程對象和start() 寫在

　　 if __name__ == '__main__' 下面.    

　　　　在 linux和ios來講, 是徹底複製全部的變量一份放到子進程裏面, 因此 不用加 if __name__ == '__main__'　　

2 進程的兩種開啓方法

  (1) p = Process(target=None,args(,))

from multiprocessing import Process
import time
import os

def func(i):
    time.sleep(1)
    print('這裏是兒子進程,兒子本身的pid是%s,兒子的父進程的pid是%s'%(os.getpid(),os.getppid()))

# os.getpid()獲取的是當前進程本身的pid
# os.getppid()獲取的是當前進程的父進程的pid
if __name__ == '__main__':
    p = Process(target=func,args=(1,))# 實例化一個進程對象
    p.start()# 開啓一個子進程
    print('這裏是父親進程，父進程本身的pid是：%s,父親的父親的pid是%s'%(os.getpid(),os.getppid()))

  (2) 自定義類，繼承Process父類

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__':
    p1 = MyProcess()
    p1.start()# 是指，解釋器告訴操做系統，去幫我開啓一個進程，   就緒狀態
    # p1.run()# 告訴操做系統，如今立刻幫我執行這個子進程           執行


class MyProcess(Process):
    def __init__(self):
        super(MyProcess, self).__init__()#  執行父類的__init__方法
        # self.name = name

    def run(self):
        print('這是以繼承類的方式開啓的子進程,他的名字是%s'%self.name)

if __name__ == '__main__':
    p1 = MyProcess()
    p1.start()# 是指，解釋器告訴操做系統，去幫我開啓一個進程，   就緒狀態
    p1.run()# 告訴操做系統，如今立刻幫我執行這個子進程           執行

　　

3 進程的經常使用方法
  （1） start()  開啓一個子進程
  （2） join()   異步變同步（就是讓父進程停留在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()# 是讓主進程等待子進程執行完。  現象：主進程執行到這句話，主進程阻塞住，等待子進程執行
    for i in range(100):
        time.sleep(0.01)
        print('爸爸')

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

  （3） is_alive() 判斷進程是否活着
  （4） terminate()   殺死進程

from multiprocessing import Process
import time

def func():
    time.sleep(1)
    print(123)

if __name__ == '__main__':
    p=Process(target=func,)
    p.start()
    p.terminate()# 殺死p進程,讓解釋器告訴操做系統，請殺掉p進程。
    time.sleep(0.0002)
    print('子進程是否還活着？', p.is_alive())
    time.sleep(0.2)
    print('子進程是否還活着？', p.is_alive())# 返回一個bool值，若是返回True，表明進程還活着,
                                        # 若是返回False，表明子進程死了

# p.is_alive() 判斷p進程是否還活着
# p.terminate() 殺死p進程

4 進程的經常使用屬性
   （1） p.name =    給p進程一個名字
   （2） p.pid       返回p進程的pid
   （3） p.daemon = True   將p進程設置爲守護進程。（True爲守護進程，False爲普通進程）
       守護進程的兩個特色：
          守護進程會隨着父進程的結束而結束
          守護進程不能再建立子進程（不能要孩子）

 　　　　守護進程:

from multiprocessing import Process
import time

def func():
    time.sleep(100)
    print('這裏是兒子哦')

if __name__ == '__main__':
    p = Process(target=func)
    p.daemon = True # 將p進程設置爲守護進程,必需要在start以前設置
    p.start()
    time.sleep(1)
    print('這是爸爸')
###### 守護進程：跟隨着父進程的代碼執行結束，守護進程就結束

from multiprocessing import Process
import time

def func1():
    print('孫子')

def func():
    p = Process(target=func1)
    p.start()
    time.sleep(3)
    print('兒子')

if __name__ == '__main__':
    p=Process(target=func)
    p.daemon = True
    p.start()
    time.sleep(1)
    print('爸爸')
####守護進程：不容許開啓子進程
from multiprocessing import Process
import time

def func():
    for i in range(100):
        time.sleep(1)
        print(time.strftime('%Y:%m:%d'))
        print(time.strftime('%H:%M:%S'))

if __name__ == '__main__':
    p = Process(target=func)
    p.daemon = True
    p.start()
    time.sleep(5)
    print('爸爸')
#######將p進程設置爲守護進程,必需要在start以前設置

　　

5,如何開啓多個不一樣的子進程

from multiprocessing import Process
import time
import os

def func(i):
    time.sleep(1)
    print('這裏是兒子%s進程,兒子本身的pid是%s,兒子的父進程的pid是%s'%(i,os.getpid(),os.getppid()))


if __name__ == '__main__':
    for i in range(2):
        p = Process(target=func,args=(i,))
        p.start()
    print('這裏是父親進程，父進程本身的pid是：%s,父親的父親的pid是%s'%(os.getpid(),os.getppid()))

# os.getpid()獲取的是當前進程本身的pid
# os.getppid()獲取的是當前進程的父進程的pid
# p = Process(target=func,args=(i,))# 實例化一個進程對象
# p.start()# 開啓一個子進程

　　多個子進程:

from multiprocessing import Process
import time
import random

def func(i):
    print('我是%s'%i)

if __name__ == '__main__':
    l=[]
    addr = ['河南的','湖南的','海南的']
    for i in addr:
        p=Process(target=func,args=(i,))
        p.start()
        # p.join()
        l.append(p)
    [p.join() for i in l]
    time.sleep(0.1)
    print('我選%s'%(random.choice(addr)))