开启进程

方式一

from multiprocessing import Process
import time

def task(name):
    print('%s is running' %name)
    time.sleep(2)

if __name__ == '__main__': #在windows系统下，开子进程的代码必须写到这一行下面
    p=Process(target=task,args=('egon',))
    p.start() #只是在给操作系统发了一个信号，让操作系统去开进程（申请内存+拷贝父进程的地址空间）
    print('主')
#主
#egon is running

方式二(不常用)

继承Process类

from multiprocessing import Process
import time
#
class Myprocess(Process):
    def __init__(self,name):
        super().__init__()
        self.name=name
    def run(self):
        time.sleep(3)
        print('%s is running' % self.name)
        time.sleep(2)


if __name__ == '__main__':  # 在windows系统下，开子进程的代码必须写到这一行下面
    p = Myprocess('egon')
    p.start()  # p.run()
    print('主')

#主
#egon is running

 Process对象的属性与方法

最重要的两个 start()  join()

start()用于开启子进程

join()用于等待子进程完成

 

from multiprocessing import Process
import time,random
def func(name):
    print('%s is runing' %name)
    time.sleep(random.randint(1,3))
    print('%s is done' %name)

if __name__ == '__main__':
    p1 = Process(target=func,args=("one",))
    p2 = Process(target=func,args=("two",))
    p1.start()
    p2.start()

    print("hahaha")
# start() #只是在给操作系统发了一个信号，让操作系统去开进程（申请内存+拷贝父进程的地址空间）
# 所以程序会继续向下执行
#结果
#hahaha
#one is runing
#two is runing
#one is done
#two is done

 然而有时我们需要在子进程完成之后进行操作，这是就用到了join()

from multiprocessing import Process
import time,random
def func(name):
    print('%s is runing' %name)
    time.sleep(random.randint(1,3))
    print('%s is done' %name)

if __name__ == '__main__':
    p1 = Process(target=func,args=("one",))
    p2 = Process(target=func,args=("two",))
    p1.start()
    p2.start()

    p1.join()
    p2.join()
    print("hahaha")
#p.join([timeout])
#主线程等待p终止（强调：是主线程处于等的状态，而p是处于运行的状态）。timeout是可选的超时时间，
#需要强调的是，p.join只能join住start开启的进程，而不能join住run开启的进程
#在上面代码中等待子进程结束的时候，p1,p2两个进程是同时运行的 
#如果staer后紧跟join则会等待子进程完成后才会执行就失去了并发的功能

#结果
#one is runing
#two is runing
#one is done
#two is done
#hahaha

 其他操作

#terminate是给操作系统发信号，让操作系统去关闭进程
#然而这并没有什么卵用，强制终止进程p，不会进行任何清理操作，如果p创建了子进程，该
#子进程就成了僵尸进程，使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将#不会被释放，进而导致死锁

#is_alive是判断子进程是否在运行
#运行返回True，不运行返回Flase
#terminate()
from multiprocessing import Process
import time,random
def func(name):
    print('%s is runing' %name)
    time.sleep(2)
    print('%s is done' %name)

if __name__ == '__main__':
    p1 = Process(target=func,args=("one",))
    p1.start()
    p1.terminate()
    p1.join()
    print("hahaha")
#执行结果
#hahaha

#is_alive()
from multiprocessing import Process
import time,random
def func(name):
    print('%s is runing' %name)
    time.sleep(2)
    print('%s is done' %name)

if __name__ == '__main__':
    p1 = Process(target=func,args=("one",))
    p1.start()
    print(p1.is_alive())
    p1.join()
    print("hahaha")
#执行结果
#True
#one is runing
#one is done
#hahaha

#然而
from multiprocessing import Process
import time,random
def func(name):
    print('%s is runing' %name)
    time.sleep(2)
    print('%s is done' %name)

if __name__ == '__main__':
    p1 = Process(target=func,args=("one",))
    p1.start()
    p1.terminate()
    print(p1.is_alive())
    p1.join()
    print("hahaha")
#执行结果
#True
#hahaha
#出现这种情况的原因是terminate通知操作系统关闭进程，代码继续向下运行is_alive时进程还是开着的

#name是Process对象的一个属性，由默认值，也可以自己指定
#pid 进程id
def piao(name):
    print('%s is wuwuwa' % name)

if __name__ == '__main__':
    p1=Process(target=piao,args=('alex',))
    p2=Process(target=piao,args=('alex',))
    p3=Process(target=piao,args=('alex',),name="hahaha")

    p1.start()
    print(p1.name)
    print(p2.name)
    print(p3.name)

    print(p1.pid)

    print('主')
#运行结果
#Process-1
#Process-2
#hahaha
#1468
#主
#alex is wuwuwa