python学习Day35--进程

一、回顾

1、编程语言的发展

　　机器语言：二级制

　　汇编语言：指令，命令形式

　　高级语言：面向过程（C），面向对象（python）

2、操作系统的目标：

　　为了用户更方便的使用。

3、并行与并发：

　　并行：指两件或多件事情，在同一时间点同时执行

　　并发：指两件或多件事情，在同一时间间隔内同时执行

4、计算机组成

　　CPU，主板，存储，输入，输出

5、进程由三部分组成

　　代码段、数据段、PCB（进程控制块）

6、进程的三个基本状态

　　就绪状态：获得了除CPU之外运行需要的所有资源

　　执行状态：获得了所有资源，处于正在执行的状态

　　阻塞状态：因为各种原因，导致进程放弃了CPU，导致进程无法继续执行，此时进程处于内存

7、为什么要有操作系统？

（1）封装了所有硬件的接口，使用户更方便的使用

（2）对于计算机内所有资源，进行一个合理的调度和分配

二、进程学习

1、进程三状态转换图

2、同步与异步

　　所谓同步就是一个任务需要依赖另一个任务时，只有等待被依赖的任务完成后，依赖的任务才能算完成，这是一种可靠的任务序列。要目成功都成功，失败都失败，两个任务的状态可以保持一致。

　　所谓异步是不需要等待被依赖的任务完成，只是通知被依赖的任务要完成什么工作，依赖的任务也立即执行，只要自己完成了整个任务就算完成了。

3、同步/异步与阻塞/非阻塞

（1）同步阻塞形式

（2）异步阻塞形式

（3）同步非阻塞形式

（4）异步非阻塞形式

4、多进程的开启

（1）如何开启多个不同的子进程？

from multiprocessing import Process
import time
import os


def func(n):
    time.sleep(2)
    print('这里是儿子%s进程,儿子的pid是:%s,父进程的pid是：%s' % (n,os.getpid(),os.getppid()))

if __name__ == '__main__':
    for i in range(2):
        p = Process(target=func,args=(i,)) # 实例化一个进程对象
        p.start() # 开启进程
    print('这里是父亲的进程,父亲的pid是：%s'% (os.getpid()))
    
'''
这里是父亲的进程,父亲的pid是：26920
这里是儿子0进程,儿子的pid是:14480,父进程的pid是：26920
这里是儿子1进程,儿子的pid是:21424,父进程的pid是：26920
'''

（2）以继承的方式开启子进程

# *******************以继承的方式开启子进程**********************开始
from multiprocessing import Process

class MyProcess(Process):
    def __init__(self,name):
        self.name = name
        super(MyProcess,self).__init__(name=self.name)

    def run(self):
        print("这是以继承类的方式开启的子进程,他的名字是：%s" % self.name)

if __name__ == '__main__':
    p = MyProcess('alex')# 实例化一个进程对象
    p.start() # 指解释器告诉操作系统，去帮我开启一个进程     就绪状态
    # p.run()  # 告诉操作系统，现在马上帮我执行这个子进程    执行状态
# *******************以继承的方式开启子进程**********************结束

【注意】开启一个正常的子进程，父进程会等待子进程结束后，父进程也就是程序才结束。

【注意】p.join( )的作用，主进程执行这个，就会变成同步形式；若不执行这个，就是异步形式。

　　　　join( )必须放在start后面。

p = MyProcess('alex')# 实例化一个进程对象
p.start() # 指解释器告诉操作系统，去帮我开启一个进程     就绪状态
p.join() # 是让主进程等待子进程执行完毕。
time.sleep(1)
print('粑粑在这里')

5、进程的其他常用

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进程。
    print('子进程是否还活着？', p.is_alive())
    time.sleep(0.002)
    print('子进程是否还活着？', p.is_alive())
    # 返回一个bool值，如果返回True，代表进程还活着,如果返回False，代表子进程死了

# p.is_alive() 判断p进程是否还活着
# p.terminate() 杀死p进程

 6、进程的常用属性

（1）守护进程：将子进程设置为守护进程，主进程结束后，子进程也随之结束。

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 func():
    for i in range(10):
        time.sleep(1)
        print(time.strftime('%H:%M:%S'))

if __name__ == '__main__':
    p = Process(target=func)
    p.daemon = True # 将p进程设置为守护进程,必须要在start之前设置
    p.start()
    time.sleep(5)
    print('这是爸爸')

（2）常用属性

from multiprocessing import Process
import os

def func():
    print('这里是儿子,儿子的pid是%s'%(os.getpid()))

if __name__ == '__main__':
    p = Process(target=func)
    p.start()
    p.name = 'alex'
    print('儿子的名字是%s'%p.name)
    print('儿子的pid是%s'%p.pid)
    print('儿子是不是守护进程？',p.daemon)

7、总结

（1）进程的两种开启方法

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

　　② 自定义类，继承Process父类

（2）进程的常用方法

　　① start()　　开启一个进程

　　② join()　　  异步变同步

　　③ is_alive()  判断进程是否活着

　　④ terminate() 杀死进程

（3）进程的常用属性

　　① p.name=         给进程一个名字

　　② p.pid               返回p进程的pid

　　③ p.daemon=True   将p进程设置为守护进程。

　　　　守护进程两个特点：

　　　　　　守护进程会随着父进程的iehu而结束；

　　　　　　守护进程不能在创建子进程。

 8、多个子进程演示

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 p in l]
    time.sleep(1)
    print('我选%s'%(random.choice(addr)))