day28 进程（Process）

1、进程的概念

进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。
# 进程是系统进行资源分配和调度的基本单位

程序：做事的过程，而且是没有生命周期的，程序是永久的
进程：是动态的，是有生命周期的，进程是暂时的 
协程：解决单线程下的高并发

# 进程中还可以开线程
线程就是干活的人，进程不是干活的人
线程就是最小的执行单元

进程和线程都是有操作系统来调度的

2、进程的并行和并发

一、进程的并行和并发
并行： 并行是指两者同时执行，比如赛跑，两个人都在不停的往前跑（比如三个线程，四核的CPU）
并发：并发是指资源有限的情况下，两者交替轮流使用资源（比如单核CPU，只能两个人来回交替使用，目的是提高效率）
二、并行和并发的区别
并行是从微观上，就是在一个精确的时间片刻，有不同的程序在同时执行，这就要求必须有多个处理器。
并发是从宏观上，在一个时间段可以看出是同时执行的，# 但原理是多个程序来回交替使用的。
三、消耗
1. i/o消耗（i/o密集型）
	input：输入
	output：输出
    不需要用到CPU的
	比如：在一个网站下载文件，下载时间为3秒，这个过程及时i/o消耗
2.计算密集型
	需要占用CPU

3、进程调度算法

一、先来先服务调度算法
	先来先服务调度算法是一种最简单的调度算法，该算法既可以用于作业调度，也可用于进程调度。FCFS算法比较有利于长作业（进程），而不利于短作业（进程）。由此可知，本算法适合于CPU繁忙型作业，而不利于O/O繁忙型的作业（进程）。
二、短作业优先调度算法
	短作业（进程）优先调度算法是指对短作业或短进程优先调度的算法，该算法既可用于作业调度，也可用于进程调度。
三、时间片轮转法
	时间片轮转法的基本思路是让每个进程在就绪队列中的等待时间与享受服务的时间成比列。

4、同步异步阻塞和非阻塞

# 在程序运行的过程中，由于被操作系统的调度算法控制，程序会进入几个状态：就绪，运行和阻塞。
1.同步与异步: 同步和异步关注的是消息通信机制
2. 阻塞与非阻塞:阻塞和非阻塞关注的是程序在等待调用结果（消息，返回值）时的状态.
同步：就是一个任务的完成需要依赖另外一个任务时，只有等待被依赖的任务才算完成，这是一种可靠序列。要么成功都成功，失败都失败，状态保持一致。
异步：是不需要等待被依赖的任务完成，只是通知被依赖的任务要完成什么工作，依赖的任务也立即执行，只要自己完成了任务就算完成了。所以它是不可靠的任务序列。
	通俗一点讲：同步 比喻成一个人去书店买书，问书店老板有没有这本书，书店老板给你找，而在这个过程中，你是一直在书店等待书店老板返回的结果。# 是一种效率低下的方式。
    异步：让老板先找书，自己先去工作，找到书了给自己打电话，再来拿书。# 这是一种效率高的方式。
同步阻塞的方式：效率低下，只能等待返回结果，干不了其他事情
异步阻塞的方式：效率更高，在等待返回结果先干别的事情，返回结果再来干这件事。

5、如何开启进程

一、multiprocess模块：多功能的意思
	分为四部分：创建进程部分，进程同步部分，进程池部分，进程之间数据共享。
二、multiprocess.process模块
	process模块是一个创建进程的模块，借助这个模块，就可以完成进程的创建。
代码：
    from multiprocessing import Process

    def write():
        with open('aaa','w') as f:
            f.write('hello')

    # 一个进程必须至少有一个线程
    # 在winds中，开启进程必须写在__main__里面
    if __name__ == '__main__':
        p = Process(target=weite)

        # 开启进程必须调用start方法
        p.start()

6、process类的参数

参数介绍：
1.group参数未使用，值始终为None
2.target表示调用对象，即子进程要执行的任务
3.args表示调用对象的位置参数元祖，args=（1,2，'meng'）
4.kwargs表示调用对象的字典，kwargs={'name':'meng','age':18}
5.naem为子进程的名称

from multiprocessing import Process

def task(age, name):
    # with open('aaa', 'w') as f:
    #     f.write('hello')
    print(name)
    print(age)

# 一个进程中必须至少有一个线程
# 在wins中，开启进程必须写在__main__里面
if __name__ == '__main__':
    """
            target=None, name=None, args=(), kwargs={},
                     *, daemon=None
    """
    # p = Process(target=write, name='meng')
    # p = Process(target=task, args=('meng', 18))
    p = Process(target=task, kwargs={'name': 'meng', 'age': 18})

    # 开启进程必须调用start方法
    p.start()

    print(p.name)  # 进程名：Process-1

7、process类的方法

方法：
1.p.start():启动进程，并调用该子进程中的p.run()
2.p.run():进程启动时运行的方法，正是它去调用target指定的函数、
3.p.terminate():强制终止进程p，不会进行任何操作。
4.p.is_alive()：如果p仍在运行，返回True
5.p.join()：等子进程运行完在执行，注意：p.join只能在statr开启的进程，不能在run开启的进程
代码：
    from multiprocessing import Process
    import time

    def task(age, name):
        # with open('aaa', 'w') as f:
        #     f.write('hello')
        print(name)
        # print(age)

    # 一个进程中必须至少有一个线程
    # 在wins中，开启进程必须写在__main__里面
    if __name__ == '__main__':

        p = Process(target=task, kwargs={'name': 'meng', 'age': 18})
        # 开启进程必须调用start方法
        p.start()
        # # p.run() # 也可以开启进程
        # print(p.is_alive())  # 判断这个进程是否存活，结果True
        # time.sleep(2)
        # p.terminate() # 杀死这个进程
        print(p.is_alive())  # 结果False
        p.join() # 等待子进程执行完毕再执行
        '''
            子进程
            父进程
        '''
        print('=====>')

8、process类的属性介绍

属性介绍：
1.p.daemon:默认值为False，如果设为True，代表p为后台运行的守护进程，当p的父进程终止时，p也随之终止，并且设定为True后，p不能创建自己的新进程，必须在p.start()之前设置
2.p.name:进程的名称
3.p.pid:进程的pid
4.p.exitcode:进程在运行时为None、如果为–N，表示被信号N结束(了解即可)
5.p.authkey：进程的身份验证键,默认是由os.urandom()随机生成的32字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性，这类连接只有在具有相同的身份验证键时才能成功（了解即可）
代码：
from multiprocessing import Process
import time
def task(age, name):
    # with open('aaa', 'w') as f:
    #     f.write('hello')
    # print(name)
    # print(age)
    time.sleep(2)
    print(name)

# 一个进程中必须至少有一个线程
# 在wins中，开启进程必须写在__main__里面
if __name__ == '__main__':
    p = Process(target=task, kwargs={'name': 'meng', 'age': 18})
    '''
        守护进程：父进程执行完毕，子进程也立即结束
    '''
    p.daemon = True  # 强调：一定要放在start之前
    # 正常输出Process-1，meng。 加上p.demon不会运行meng,直接运行print(p.name)
    # 开启进程必须调用start方法
    p.start()
    print(p.pid)   # 可以查看子进程的pid
    print(p.name)  # 进程名：Process-1

9、获取进程id号

代码：
    from multiprocessing import Process
    import os
    import time

    def task(name,age):
        print('子进程的id号：%s'% os.getpid())
        print('父进程的id号：%s'% os.getppid())
        time.sleep(10)

    if __name__ == '__main__':
        p = Process(target = task,kwargs={'name':'meng','age':18})
        p.start()
        print(p.pid)
        print('main里的主进程的id号：%s'% os.getpid())
        print('main里的父进程的id号：%s'% os.getppid())
        time.sleep(10)
        print('====>')
    输出结果：可以打开资源管理器看看
    	33540
        main里的主进程的id号：32680
        main里的父进程的id号：28896
        子进程的id号：33540
        父进程的id号：32680
        ====>

10、开启多进程

代码：
    from multiprocessing import Process
    import time
    import os

    def task(i):
        time.sleep(2)
        print(i)

    if __name__ == '__main__':
        l = []
        for i in range(10):
            p = Process(target=task,args=(i,))
            p.start()
            l.append(p)

        for j in l:
            j.join()
        # 开启10次进程