python中的进程

最新推荐文章于 2024-10-13 23:49:20 发布

冰鑫999

最新推荐文章于 2024-10-13 23:49:20 发布

阅读量872

点赞数 25

分类专栏： python 文章标签： python 网络

本文链接：https://blog.csdn.net/imouse728/article/details/140812673

版权

python 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

文章目录

1 函数式方式创建进程
2 继承的方式创建进程
3 Pool进程池
- 非阻塞的形式
- - 阻塞的方式
4 进程之间的通信
- 4.1 Queue对象
- 4.2 通过队列进行通信

1 函数式方式创建进程

1.1 语法：

Process(group=None,target,name,args,kwargs)
参数：
group:表示分组，实际上不使用，None即可
target：表示子进程要执行的任务，支持函数名
name：表示子进程的名称
args：表示调用参数的位置参数，以元组的形式进行传递
kwargs：表示调用函数的关键字参数，以字典的形式进行传递

1.2 Process对象的主要方法

方法/属性名称	功能描述
name	当前进程实例别名，默认为Process-N
pid	当前进程对象的PID值
is_alive()	进程是否执行完，没执行完结果为True，否则为False
join(timeout)	等待结束或等待timeout秒
start()	启动进程
run()	如果没有指定target参数，则启动进程后会调用父类中的run方法
terminate()	强制终止进程

1.3 创建进程

from multiprocessing import Process
import os,time
def test():
    print(f'hello，我的PIP是：{os.getpid()},我的父进程是：{os.getppid()}')

if __name__ == '__main__':
    print('主进程开始执行！')
    test()
    # 创建一个子进程
    p = Process(target=test)
    p.start()
    p.join() # 阻塞主进程
    
    print('主进程执行结束')

输出
主进程开始执行！
hello，我的PIP是：1328,我的父进程是：19132
hello，我的PIP是：15788,我的父进程是：1328
主进程执行结束

1.4 进程执行状态

from multiprocessing import Process
import os,time
def test_process(name):
    print(f'hello {name}，我的PIP是：{os.getpid()},我的父进程是：{os.getppid()}')
    time.sleep(2) # 休眠2秒

if __name__ == '__main__':
    print('主进程开始执行！')
    test_process('主线程')
    # 创建一个子进程
    p = Process(target=test_process,args=('test',))
    p.start()
    print(p.name,'是否执行完毕：',p.is_alive())
    p.join() # 阻塞主进程

    print('主进程执行结束')
    print(p.name, '是否执行完毕：', p.is_alive())

输出
主进程开始执行！
hello 主线程，我的PIP是：6672,我的父进程是：18708
Process-1 是否执行完毕 True
hello test，我的PIP是：5312,我的父进程是：6672
主进程执行结束
Process-1 是否执行完毕 False

1.5 进程执行的顺序

如果没有p.join()代码，那么子进程的执行将会变得无序

有阻塞主进程时

from multiprocessing import Process
import os,time
def test_process(name):
    print(f'hello {name}，我的PIP是：{os.getpid()},我的父进程是：{os.getppid()}')
    time.sleep(1) # 休眠2秒

if __name__ == '__main__':
    print('主进程开始执行！')
    test_process('主线程')
    # 创建一个子进程
    for i in range(5):
        p = Process(target=test_process,args=('test',))
        p.start()
        print(p.name,'是否执行完毕：',p.is_alive())
        p.join() # 阻塞主进程
        print(p.name, '是否执行完毕：', p.is_alive())

    print('主进程执行结束')

输出
主进程开始执行！
hello 主线程，我的PIP是：20272,我的父进程是：20180
Process-1 是否执行完毕： True
hello test，我的PIP是：14440,我的父进程是：20272
Process-1 是否执行完毕： False
Process-2 是否执行完毕： True
hello test，我的PIP是：12880,我的父进程是：20272
Process-2 是否执行完毕： False
Process-3 是否执行完毕： True
hello test，我的PIP是：17132,我的父进程是：20272
Process-3 是否执行完毕： False
Process-4 是否执行完毕： True
hello test，我的PIP是：10588,我的父进程是：20272
Process-4 是否执行完毕： False
Process-5 是否执行完毕： True
hello test，我的PIP是：19568,我的父进程是：20272
Process-5 是否执行完毕： False
主进程执行结束

无阻塞主进程时

from multiprocessing import Process
import os,time
def test_process(name):
    print(f'hello {name}，我的PIP是：{os.getpid()},我的父进程是：{os.getppid()}')
    time.sleep(1) # 休眠2秒

if __name__ == '__main__':
    print('主进程开始执行！')
    test_process('主线程')
    # 创建一个子进程
    for i in range(5):
        p = Process(target=test_process,args=('test',))
        p.start()
        print(p.name,'是否执行完毕：',p.is_alive())
        # p.join() # 阻塞主进程
        print(p.name, '是否执行完毕：', p.is_alive())

    print('主进程执行结束')

输出
主进程开始执行！
hello 主线程，我的PIP是：20324,我的父进程是：19912
Process-1 是否执行完毕： True
Process-1 是否执行完毕： True
Process-2 是否执行完毕： True
Process-2 是否执行完毕： True
Process-3 是否执行完毕： True
Process-3 是否执行完毕： True
Process-4 是否执行完毕： True
Process-4 是否执行完毕： True
Process-5 是否执行完毕： True
Process-5 是否执行完毕： True
主进程执行结束
hello test，我的PIP是：19408,我的父进程是：20324
hello test，我的PIP是：17520,我的父进程是：20324
hello test，我的PIP是：16856,我的父进程是：20324
hello test，我的PIP是：18552,我的父进程是：20324
hello test，我的PIP是：20336,我的父进程是：20324

1.6 有参的函数式方式

from multiprocessing import Process
import os,time
def test_process(name):
    print(f'hello {name}，我的PIP是：{os.getpid()},我的父进程是：{os.getppid()}')

if __name__ == '__main__':
    print('主进程开始执行！')
    test_process('主线程')
    # 创建一个子进程
    p = Process(target=test_process,args=('test',))
    p.start()
    p.join() # 阻塞主进程

    print('主进程执行结束')

输出
主进程开始执行！
hello 主线程，我的PIP是：17400,我的父进程是：8976
hello test，我的PIP是：12952,我的父进程是：17400
主进程执行结束

1.7 没有指定target

如果在创建Process对象时指定了target参数，start()方法会调用target指定的函数去执行，没有指定target参数，start()方法会调用Process类中的run方法去执行

子进程没有指定target函数

from multiprocessing import Process
import os,time
def test_process(name):
    print(f'hello {name}，我的PIP是：{os.getpid()},我的父进程是：{os.getppid()}')

if __name__ == '__main__':
    print('主进程开始执行！')
    test_process('主线程')
    # 创建一个子进程
    p = Process()
    p.start()
    print('主进程执行结束')

输出
主进程开始执行！
hello 主线程，我的PIP是：14084,我的父进程是：7444
主进程执行结束
可以看到子进程中并未执行函数方法

1.8 terminate强制终止

from multiprocessing import Process
import os,time
def test_process(name):
    print(f'hello {name}，我的PIP是：{os.getpid()},我的父进程是：{os.getppid()}')

if __name__ == '__main__':
    print('主进程开始执行！')
    test_process('主线程')
    # 创建一个子进程
    p = Process(target=test_process,args=('test',))
    p.start()
    p.terminate() # 强制终止，在还没有执行到函数时就被强制终止了

    print('主进程执行结束')

输出
主进程开始执行！
hello 主线程，我的PIP是：11384,我的父进程是：19940
主进程执行结束

注意：在还没有执行到target函数时就被强制终止了，因此未打印子进程的信息

2 继承的方式创建进程

语法：

class 子进程(Process):
	pass

重写父类中的 run方法

from multiprocessing import Process
import os,time

class MyProcess(Process):

    def __init__(self,name):
        super().__init__()
        self.name = name

    # 重写父类中的run方法
    def run(self):
        print(f'子进程的名称{self.name},PID:{os.getpid()}, 父进程PID:{os.getppid()}')


if __name__ == '__main__':
    print('父进程开始执行')

    for i in range(5):
        p=MyProcess(f'进程{i}')
        p.start()
        # 阻塞主线程
        p.join()

    print('父进程开始执行结束')

输出：
父进程开始执行
子进程的名称进程0,PID:19628, 父进程PID:12332
子进程的名称进程1,PID:17372, 父进程PID:12332
子进程的名称进程2,PID:17880, 父进程PID:12332
子进程的名称进程3,PID:18892, 父进程PID:12332
子进程的名称进程4,PID:17840, 父进程PID:12332
父进程开始执行结束

3 Pool进程池

进程池的原理：
因为创建进程与销毁进程会占用很多的系统资源，因此创造一个进程池理论，所谓进程池指的是将一定数量的进程放到一个容器中，当有任务时，从进程池中获取进程执行任务，任务完成后进程重新回到进程池。假设进程池中最大的进程数是3，现在有10个任务需要执行，那么进程池一次可以执行3个任务，4次即可完成全部任务的执行
语法：

进程池对象=Pool(N)

Pool对象常用的方法

方法名	功能描述
apply_async(func,args,kwargs)	使用非阻塞方式调用函数func
apply(func,args,kwargs)	使用阻塞方式调用函数func
close()	关闭进程池，不再接收新任务
terminate()	不管任务是否完成，立即终止
join()	阻塞主进程，必须在terminate()或close()之后中使用

非阻塞的形式

from multiprocessing import Pool
import time,os

# 任务函数
def task(name):
    print(f'子进程的PID:{os.getpid()}，执行的任务：{name}')
    time.sleep(1)

if __name__ == '__main__':
    start=time.time()
    print('父进程开始执行！')
    # 创建进程池
    p=Pool(4)
    #创建任务
    for i in range(10):
        # 以非阻塞的方式
        p.apply_async(task, args=(i,))
    p.close()
    p.join() # 阻塞父进程，等所有的任务全部执行完成
    print('所有的任务均已经执行完毕')
    print(time.time()-start)

输出
父进程开始执行！
子进程的PID:19064，执行的任务：0
子进程的PID:15372，执行的任务：1
子进程的PID:20440，执行的任务：2
子进程的PID:16528，执行的任务：3
子进程的PID:19064，执行的任务：4
子进程的PID:15372，执行的任务：5
子进程的PID:20440，执行的任务：6
子进程的PID:16528，执行的任务：7
子进程的PID:19064，执行的任务：8
子进程的PID:15372，执行的任务：9
所有的任务均已经执行完毕
3.225069284439087

非阻塞的方式，每次执行4个（进程池的进程数）

阻塞的方式

from multiprocessing import Pool
import time,os

# 任务函数
def task(name):
    print(f'子进程的PID:{os.getpid()}，执行的任务：{name}')
    time.sleep(1)

if __name__ == '__main__':
    start=time.time()
    print('父进程开始执行！')
    # 创建进程池
    p=Pool(4)
    #创建任务
    for i in range(10):
        # 以阻塞的方式
        p.apply(task, args=(i,))
    p.close()
    p.join() # 阻塞父进程，等所有的任务全部执行完成
    print('所有的任务均已经执行完毕')
    print(time.time()-start)

输出
父进程开始执行！
子进程的PID:20180，执行的任务：0
子进程的PID:11928，执行的任务：1
子进程的PID:17828，执行的任务：2
子进程的PID:18652，执行的任务：3
子进程的PID:20180，执行的任务：4
子进程的PID:11928，执行的任务：5
子进程的PID:17828，执行的任务：6
子进程的PID:18652，执行的任务：7
子进程的PID:20180，执行的任务：8
子进程的PID:11928，执行的任务：9
所有的任务均已经执行完毕
10.234788417816162

阻塞的方式，每次执行1个，执行完成后，再执行下一个
可以后到，阻塞的方式，是一个进程一个进程执行的，执行完成需要的时间远远大于非阻塞的方式

4 进程之间的通信

4.1 Queue对象

Queue.qsize()
返回队列的大致大小。注意，qsize() > 0 不保证后续的 get() 不被阻塞，qsize() < maxsize 也不保证 put() 不被阻塞。

Queue.empty()
如果队列为空，返回 True ，否则返回 False 。如果 empty() 返回 True ，不保证后续调用的 put() 不被阻塞。类似的，如果 empty() 返回 False ，也不保证后续调用的 get() 不被阻塞。

Queue.full()
如果队列是满的返回 True ，否则返回 False 。如果 full() 返回 True 不保证后续调用的 get() 不被阻塞。类似的，如果 full() 返回 False 也不保证后续调用的 put() 不被阻塞。

Queue.put(item, block=True, timeout=None)
将 item 放入队列。如果可选参数 block 是 true 并且 timeout 是 None (默认)，则在必要时阻塞至有空闲插槽可用。如果 timeout 是个正数，将最多阻塞 timeout 秒，如果在这段时间没有可用的空闲插槽，将引发 Full 异常。反之 (block 是 false)，如果空闲插槽立即可用，则把 item 放入队列，否则引发 Full 异常 ( 在这种情况下，timeout 将被忽略)。

Queue.put_nowait(item)
相当于 put(item, False) 。

Queue.get(block=True, timeout=None)
从队列中移除并返回一个项目。如果可选参数 block 是 true 并且 timeout 是 None (默认值)，则在必要时阻塞至项目可得到。如果 timeout 是个正数，将最多阻塞 timeout 秒，如果在这段时间内项目不能得到，将引发 Empty 异常。反之 (block 是 false) , 如果一个项目立即可得到，则返回一个项目，否则引发 Empty 异常 (这种情况下，timeout 将被忽略)。
POSIX系统3.0之前，以及所有版本的Windows系统中，如果 block 是 true 并且 timeout 是 None ，这个操作将进入基础锁的不间断等待。这意味着，没有异常能发生，尤其是 SIGINT 将不会触发 KeyboardInterrupt 异常。

Queue.get_nowait()
相当于 get(False) 。
提供了两个方法，用于支持跟踪排队的任务是否被守护的消费者线程完整的处理。

Queue.task_done()
表示前面排队的任务已经被完成。被队列的消费者线程使用。每个 get() 被用于获取一个任务，后续调用 task_done() 告诉队列，该任务的处理已经完成。
如果 join() 当前正在阻塞，在所有条目都被处理后，将解除阻塞(意味着每个 put() 进队列的条目的 task_done() 都被收到)。
如果被调用的次数多于放入队列中的项目数量，将引发 ValueError 异常。

Queue.join()
阻塞至队列中所有的元素都被接收和处理完毕。
当条目添加到队列的时候，未完成任务的计数就会增加。每当消费者线程调用 task_done() 表示这个条目已经被回收，该条目所有工作已经完成，未完成计数就会减少。当未完成计数降到零的时候， join() 阻塞被解除。

4.2 通过队列进行通信

import time
from multiprocessing import Queue, Process


# 发送消息
def send(q):
    if not q.full():
        for i in range(6):
            a=i
            q.put(a)
            print('a入队时的值：',a)

# 接收消息
def recv(q):
    time.sleep(1)
    while not q.empty():
        print('出队时a的值：',q.get())



if __name__ == '__main__':
    print('主进程开始')
    q=Queue() # 没有指定参数，队列没有上限
    # 创建两个子进程
    p1=Process(target=send, args=(q,))
    p2=Process(target=recv, args=(q,))
    # 启动
    p1.start()
    p2.start()
    # 阻塞父进程
    p1.join()
    p2.join()
    print('主进程执行完毕')