#方式一：通过调用multiprocessing模块下面的Process类方法

'''

p = Process(target=task, args=('子进程',)) ：

target=task:指定执行任务的目标是谁   args:后面跟元组，是给target指定函数传的参数

p=Process(..)相当于是对类Process进行实例化得到了P对象

'''

from multiprocessing import Process

import time

def task(x):

    print("%s is runnin"%x)   #子进程打印输出

    time.sleep(3)

    print('%s is done'%x)     #子进程打印输出

if __name__ == '__main__':    #开进程要统一放到main方法的下面

    p=Process(target=task,args=('子进程',))

    p.start()

    print('主')  #父进程的打印输出

'''

注意点：

1.p=Process(target=task,args=('子进程',))

  这一步：只是在向操作系统发我要开启一个子进程的信号（具体开子进程的操作是由操作系统来完成的）

  *所有这个过程中的时间也是不固定的

2.p.start()：

  开启一个子进程

运行过程分析：

    右键运行父类先运行起来(此时p.start()子类也已经在造了，但是会有时间延迟)-->print('主')-->

    然后依次运行子进程里面内容;子进程 is runnin\子进程 is done

'''

#方式二：借助process类，自定义一个类（继承Process），从而造一个对象

from multiprocessing import Process

import time

class Myprocess(Process):

    #辅助理解，

    # def __init__(self,x):

    #     super().__init__()#保留原有Process类里面的方法

    #     self.name=x  #***如果要自定义传参，self.name=x必须要放到super()._init_()下面

    #

    def run(self):

        print("%s is running" % self.name)   #默认函数对象有name方法 ，结果为：Myprocess-1

        time.sleep(3)

        print('%s is done' % self.name)

if __name__ == '__main__':

    # p=Myprocess('子进程1',)     开启init方式就可以自定义参数传值

    p=Myprocess()    #实例化Myprocess类调用了类面的init方法，得到了一个对象p

    p1=Myprocess()

    p.start()    #p.run() 对象去调用了类里面的run方法，进而执行run里面的函数体代码

    p1.start()

    print('主')

from multiprocessing import Process

import time

x=100

def task():

    global x

    x=11        #当子类已经建立成功时，子类里面对数据的变动，不会印象父类

    print(x)    #

    print('done')

if __name__ == '__main__':

    p=Process(target=task)

    p.start()

    time.sleep(10) # 让父进程在原地等待10，是为了等父类先建立好，用于验证子类里面的变动不会影响父类的值

    print(x)    #打印时父类的，即全局的 100

#查看PID应用：

# print(p.pid)：外面直接查看子类pid

#os.getpid()：在内部查看子类pid

#os.getpid()：在外面查看父类的pid

#os.getppid()：在里面查看父类的pid

import time

import os

from multiprocessing import Process

def task(x):

    print('%s is running'%os.getpid())   #子进程内查看自己pid的方式

    time.sleep(100)

    print('子类下查看父类的id：%s'%os.getppid())    #查看父类的pid

    time.sleep(100)

    print('%s is done'%x)

if __name__ == '__main__':

    p=Process(target=task,args=('子进程1',))

    p.start()

    print(p.pid,)   #父进程内查看子类pid的方式

    time.sleep(50)

    print('父类下查看父类自己的id：',os.getpid())

    print('主')

import time

from multiprocessing import Process

def task(name,n):

    print('%s is running'%name)

    time.sleep(n)

    print('%s is done'%name)

if __name__ == '__main__':

    p1=Process(target=task,args=("进程1",1)) #用时1s

    p2=Process(target=task,args=("进程2",2)) #用时1s

    p3=Process(target=task,args=("进程3",3)) #用时1s

    start_time=time.time()

    p1.start()

    # p1.join()  #如果是这种情况就是总共6s左右了

    p2.start()

    # p2.join()

    p3.start()

    # p3.join()

    # 让父进程在原地等待，等子进程在运行完毕后，才执行下一行代码（）

    #注意：并不是串行，当第一秒在运行p1时，其实p2、p3也已经在运行，当1s后到p2时只需要再运行1s就到p3了，到p3也是一样。

    p1.join()

    p2.join()

    p3.join()

    stop_time=time.time()     #3.2848567962646484总结

    print(stop_time-start_time)

    print('主')