进程

进程理论：
正在进行的一个过程，而负责执行任务则是cpu
cpu执行音乐程序，执行Q聊天，执行视频播放，每一个任务都在进行中，这就是进程

程序仅仅是一堆代码，而进程指的是程序的运行过程。
同一个程序运行两次，那也是两个进程，打开影音看本地视频，突然台风袭来，了解国家情况是大事，同时打开影音看台风报告，
了解完时事新闻的重要事情之后再接着回去看视频（影音播放器为程序，进程就是这个程序的运行，同时看视频的两个运行也是并行）

并发与并行
并发：是伪并行，既看起来是同时运行，单个cpu+多道技术就可以实现并发（并行也属于并发）
并行:同时运行，只有具备多个cpu才能实现并行

 

进程的创建：
在运行时是先开创父进程内存空间，数据从硬盘载入内存，创建而成。
子进程开启内存空间是从内存将父进程数据内容当作模块拷贝到子进程内存空间。
他们初始状态一样，当子进程内存空间创造完毕之后，子进程与父进程是隔离不相连，就算改动也不会互相影响

一个进程有三种状态
运行：程序的运行
堵塞：当进程遇到IO时会堵塞，或者是长时间占用cpu会堵塞，或者优先等级原因而调用其他的进程去使用CPU
就绪：当程序准备好运行，向cpu申请运行

PID（进程开在操作系统内的身份证号）
开启子进程的两种方式：
借助multiprocessing模块中的类Process

from multiprocessing import Process
import time
def task(x):
    print("%s is runing" %x)
    time.sleep(3)
    print("%s is done" %x)

if __name__ == '__main__':#必须要有main
    p=Process(target=task,args=("子进程",))                #类调用产生对象,类调用时target执行任务的意思,
                     # target=task是关键字参数,args的值要是元组形式的内容,还有kwargs={"x":"子进程"}形式,
                     # 目前是造对象将父进程当做模块导入子进程
    p.start()        #启动子进程,是给操作系统发送一个开启子进程的信号
    print("主")      #先打印父进程内容然后打印子进程内容
    #父进程程序结束完之后并没有立刻被清空,而是等待子进程结束后,将他的还存在的pid号与状态
    # 进行回收,然后才会结束
    #如果父进程进入死循环,子循环的僵尸状态不会被回收,从而导致内存容量不断增加变卡的影响

from multiprocessing import Process
import time
class Myprocess(Process):
    def __init__(self,x):#这部可以没有自定义
        super().__init__()
        self.name=x
    def run(self):
        print("%s is runing" %self.name)#如果没有自定义类,这个进程名字也是默认自带的self.name
        time.sleep(3)
        print("%s is done" %self.name)
if __name__ == '__main__':
    p=Myprocess("子进程1")#如果没有自定义对象内容,括号里不填任何东西
    p.start() #p.run
    print("主")

x=100
def task():
    global x
    x=0
    print("done")
if __name__ == '__main__':
    p=Process(target = task)
    p.start()
    time.sleep(5)#让父进程原地等待5秒后,才执行下一行代码
    print(x)#父进程还是x=100，子进程的改变不影响父进程

进程对象的方法或属性详解：

from multiprocessing import Process
import time
def take(name):
    print("%s is runing" %name)
    time.sleep(3)
    print("%s is done" %name)

if __name__ == '__main__':
    p=Process(target=take,args=("子进程",))
    p.start()
    p.join()#让父类在原地等待,等到子进程运行完毕后,才执行下一行代码
    print("主")

from multiprocessing import Process
import time
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))
    p2=Process(target=task,args=("子进程2",2))
    p3=Process(target=task,args=("子进程3",3))
    start_time=time.time()
    p1.start()
    p2.start()
    p3.start()

    p3.join()
    p1.join()
    p2.join()

    stop_time=time.time()
    print("主",stop_time-start_time)

from multiprocessing import Process
import time
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,))
    p2 = Process(target=task,args=("子进程2",2,))
    p3 = Process(target=task,args=("子进程3",3,))

    start=time.time()
    p1.start()
    p1.join()
    p2.start()
    p2.join()
    p3.start()
    p3.join()

    stop=time.time()
    print("主",(stop-start))
    #当p1给操作系统发出信号后，父进程进入等待，等待结束后才由p2发出发出信号，这时p3并没有发出信号，
    #所以等到结束后，整体形成的是串行的模式

from multiprocessing import Process
import time
def task(name,n):
    print("%s is running" %name)
    time.sleep(n)
    print("%s is done" %name)

if __name__ == '__main__':
    p_l=[]
    start=time.time()
    for i in range(1,4):
        p=Process(target=task,args=("子进程%s" %i,i))
        p_l.append(p)
        p.start()
    for p in p_l:
        p.join()
    stop=time.time()
    print("主",(stop-start))

from multiprocessing import Process
import time
import os
def task(n):
    print("%s is running" %os.getpid())
    time.sleep(n)
    print("%s is done" %os.getpid())

if __name__ == '__main__':
    p1=Process(target=task,args=(10,))
    # print(p1.pid)#子进程并没有给操作系统信号,所以也不可能出现PID
    p1.start()
    print(p1.pid)#父进程看子pid的方式
    print("主")

from multiprocessing import Process
import time
import os

def task():
    print("自己的id: %s 父进程的id:%s" %(os.getpid(),os.getppid()))
    #getpid是目前id,getppid是目前的父进程
    time.sleep(200)

if __name__ == '__main__':
    p1=Process(target=task)
    p1.start()
    print("主",os.getpid(),os.getppid())
    #getpid是目前id,getppid是目前的父进程,父进程的爹是谁运行的就是谁(python或cmd)

通过“杀死”父进程，子进程不会消失，会由“孤儿院”__init__接管

from multiprocessing import Process,current_process
import time
def task():
    print("子进程[%s]运行" %current_process().name)
    time.sleep(200)

if __name__ == '__main__':
    p=Process(target=task,name="子进程2") #查看子进程自己的名字
    p.start()
    print("主")
    
    
    p.terminate()#杀死子进程
    time.sleep(1)
    print(p.is_alive())#将子进程存活反馈
    print("主")