进程

进程

进程的概念
    进程（Process）是资源分配的最小单位，也是线程的容器。进程会根据运行需要，让操作系统动态分配各种资源
    程序是静态的、固定不变的，一个程序运行起来后，代码+所需资源，被称为进程，它是操作系统分配资源的基本单位

进程和线程
    CPU的时间片轮转，在不同的时间段切换执行不同的进程，但切换进程耗时较大，所以引来了轻量级进程，即线程
    一个进程中包含多个线程（代码流），也就是进程中同时运行的多个方法体，如果没有进程，线程是不能独立运行的

进程的状态
    工作中，任务数往往大于CPU核心数，即一定有一些任务正在执行，而另外一些任务在等待CPU执行，因此产生了不同状态
        就绪：运行条件都已经满足，等待CPU执行
        运行：CPU正在执行其功能
        等待：等待某些条件满足，如程序sleep

     启动       调度       结束
新建 ----> 就绪 ----> 运行 ----> 死亡
            ↑          |
    满足条件 |          ↓ 等待条件
             等待（阻塞）

multiprocessing模块
    该模块是跨平台版本的多进程模块

进程的id
    可以使用 kill -9 / kill -u [进程id] 来杀死进程（Windows：taskkill /pid [pif] -f）
    获取进程的id有两种方式：
        1.multiprocessing.current_process().pid
        2.os.getpid(),os.getppid()

进程的参数传递
    子进程的参数在创建进程对象时定义，传递参数有三种方式：
        1.使用tuple传递
        2.使用dict传递
        3.混合使用tuple和dict传递

进程守护
    控制子进程的终止
        1.进程守护：obj.daemon = True
        2.终止子进程：obj.terminate()

multiprocessing
multiprocessing.Process(target=func,[name=name,[args=()/kwargs{}]])
        功能：创建子进程对象，这个对象可以理解为一个独立的进程，可以执行其他事务
        参数：
            target：如果传递了函数的引用，子进程就执行这个函数
            args=()/kwargs={}：参数列表，args=()为按顺序传递，kwargs={}为按关键字传递
            name：为进程设置名字，可选
        obj属性：
            name：当前进程名，默认为Process-N，N为从1开始递增的整数
            pid：当前进程的进程号
            daemon：值为True时激活进程守护

obj.start()
        功能：启动子进程

obj.is_alive()
        功能：判断子进程是否存活

obj.join([timeout])
        功能：是否等待子进程执行结束
        参数：timeout：等待时间，为空时则等待至执行结束

obj.terminate()
        功能：无论任务是否完成，立即终止子进程

obj.current_process()
        功能：获取当前进程对象

multiprocessing.Queue(n)
        功能：创建queue对象
        参数：n：queue的长度，若没有指定n或n为负数，代表可接收的消息数量没有上限

multiprocessing.Manager().Queue(n)
         功能：创建进程池中的queue对象
         参数：n：queue的长度

Queue_obj.put(item,[block[,timeout]])
        功能：将item写入queue
        参数：
            item：写入queue的内容
            block：控制queue没有空间可写入时的阻塞状态，默认为True
                True：没有空间可写入时，程序阻塞，进入时间为timeout的等待，若还没有空间则引发异常
                False：没有空间可写入时引发异常
            timeout：阻塞时间，单位为s

Queue_obj.put_nowait(item)
        功能：相当于queue.put(item,False)

Queue_obj.get([block[,timeout]])
        功能：获取queue中队首的值，并将其从queue中移除
        参数：
            block：控制queue为空时的阻塞状态，默认为True
                True：queue为空时，程序阻塞，进入时间为timeout的等待，若还没有读取到数据则引发异常
                False：queue为空时引发异常
            timeout：阻塞时间，单位为s

Queue_obj.get_nowait()
        功能：相当于queue.get(False)

Queue_obj.qsize()
        功能：获取当前queue中item的数量

Queue_obj.fill()
        功能：判断queue是否为满

Queue_obj.empty()
        功能：判断queue是否为空

multiprocessing.Pool(n)
        功能：创建进程池
        参数：n：进程池的长度

Pool_obj.apply(func,[args[,kwargs]])
        功能：进程池中的进程以同步方式执行任务
        参数：
            func：进程执行的方法
            args/kwargs：参数列表

Pool_obj.apply_async(func,[args[,kwargs]])
        功能：进程池中的进程以异步方式执行任务
        参数：
            func：进程执行的方法
            args/kwargs：参数列表
        返回值：ApplyResult对象，该对象有wait()方法，功能为当前进程执行完毕后续进程才能启动

Pool_obj.close()
        功能：使Pool不再接收新的任务，不影响已创建的进程

Pool_obj.terminate()
        功能：不管任务是否完成，立即终止

Pool_obj.join()
        功能：等待Pool中所有进程执行完毕再退出，必须在close或terminate之后使用

import multiprocessing
import time
import os

def work(a,b,c):
    print('参数：',a,b,c)
    for i in range(10):
        # 获取当前进程对象
        process_s = multiprocessing.current_process()
        print('work',i,process_s,process_s.pid)
        # 获取当前进程id和父进程id
        pid,ppid = os.getpid(),os.getppid()
        print(pid,ppid)
        time.sleep(0.5)


if __name__ == '__main__':
    # 获取当前进程对象
    process_main = multiprocessing.current_process()
    print(process_main,process_main.pid)
    # 获取当前进程id和父进程id
    pid,ppid = os.getpid(),os.getppid()
    print(pid,ppid)

    # 创建进程对象
    process_obj = multiprocessing.Process(target=work,name='p1',args=(10,),kwargs={'c':1000,'b':100})
    # 设置进程守护
    # process_obj.daemon = True
    # 启动进程
    process_obj.start()
    print('xxxx')

    # 控制主进程终止
    time.sleep(2)
    # 终止子进程
    process_obj.terminate()
    print('over')
    exit()
    print('xxxx....')
	
	
	
<_MainProcess(MainProcess, started)> 4140
4140 7596
xxxx
参数： 10 100 1000
work 0 <Process(p1, started)> 11180
11180 4140
work 1 <Process(p1, started)> 11180
11180 4140
work 2 <Process(p1, started)> 11180
11180 4140
over