Python - 进程管理

# 进程： 代码+资源

"""

语法结构：

1> multiprocessing 模块 Process 类
2> Process() 参数:
target:表示调用对象，即进程要执行的任务
args:给target指定的函数传参，以元组的形式传参
kwargs:字典对象传参
name:子进程名称,默认Process-N,N为从1开始递增的整数
group:指定进程组
pid：当前的进程号

"""


import os
from multiprocessing import Process


def one():
    print(f'one child process id is {os.getpid()}, parent process is {os.getppid()}')


def two():
    print(f'two child process id is {os.getpid()}, parent process is {os.getppid()}')


if __name__ == '__main__':

    p1 = Process(target=one)
    p2 = Process(target=two)

    p1.start()
    p2.start()

    p1.name = "three"

    print(f'one child process id is {p1.name}, parent process is {p1.pid}')

    print(f'main child process id is {os.getpid()}, parent process is {os.getppid()}')
#
# one child process id is three, parent process is 4232
# main child process id is 11748, parent process is 10288
# one child process id is 4232, parent process is 11748
# two child process id is 15572, parent process is 11748


"""

1> is_alive 判断进程是否活着
2> join([timeout]) join(2)
3> terminate() 终结进程

"""

from multiprocessing import Process


def sing(name):
    print(f'{name} is singing')


def dance(name):
    print(f'{name} is dancing')


if __name__ == '__main__':

    p1 = Process(target=sing, args=('noise',))
    p2 = Process(target=dance, args=('lys',))

    p1.start()
    # p1.join()
    p2.start()
    # p2.join()

    # 此时p1,p2启动等待cpu分配资源，但是主进程继续执行
    print(f'sing is {p1.is_alive()}')
    print(f'dance is {p2.is_alive()}')

# sing is True
# dance is True
# noise is singing
# lys is dancing

# 如果想p1执行完，再执行p2，这个时候可以用join或者互斥锁
# noise is singing
# lys is dancing
# sing is False -> p1 已经执行完毕，自动终结
# dance is False -> p2 已经执行完毕，自动终结
from multiprocessing import Process

import time

list1 = []


def funa():
    for i in range(3):
        list1.append(i)
        time.sleep(1)
        print(f'funa 的{list1}')


def funb():
    print('funb 的{}'.format(list1))


if __name__ == '__main__':

    p1 = Process(target=funa)
    p2 = Process(target=funb)

    p1.start()
    p1.join()
    p2.start()

#
# funa 的[0]
# funa 的[0, 1]
# funa 的[0, 1, 2]
# funb 的[]


"""
队列的基本操作：
1》 入队：将一个数据放到队列尾部
2》 出队：从队列的头部取出一个元素
支持队尾插入元素，在队头删除元素
Queue([maxsize] ) maxsize 小于或等于0，队列大小没有限制
队列常用方法
q = Queue() 初始化队列对象
q.empty() 判断是否为空，为空则为True
q.get() 取值
q.put() 赋值
q.full() 判断队列是否满了
q.qsize() 返回队列大小

"""

#
# from queue import Queue

# q = Queue(3)
# q.put('msg1')
# q.put('msg2')
# print(q.full())
# q.put('msg3')
# print(q.full())
# print(q.qsize())
# print(q.get())


from multiprocessing import Process,Queue

import time



def funa(q1):
    for i in range(3):
        q1.put(i)
        time.sleep(1)
        print("funa 的{}".format(i))


def funb(q1):

    while True:
        if not q1.empty():
            print('funb 的{}'.format(q1.get()))
        else:
            break


if __name__ == '__main__':

    q1 = Queue(3)
    p1 = Process(target=funa, args=(q1,))
    p2 = Process(target=funb, args=(q1,))

    p1.start()
    p1.join()
    p2.start()
    print("this is main program")


# funa 的0
# funa 的1
# funa 的2
# this is main program
# funb 的0
# funb 的1
# funb 的2













"""
p.apply_async(func,args,kwds) 异步非阻塞
p.close() 关闭进程池
terminate() 中止
join() 阻塞


进程池使用场景
1> 利用python 进行系统管理时，同时操作多个文件目录或远程控制多台主机，并行操作可以节约大量时间，
2> 提交任务的两种方式：
    同步调用：提交完任务后，在原地等待，知道任务完成后，拿到返回值，才继续下一行代码
    异步调用：提交完任务后，不在原地等待，直接执行下一行代码

"""


# 异步举例
import os, time

from multiprocessing import Pool


def learn(n, x):
    print('we are studying now at {}-{}'.format(os.getpid(), os.getppid()))
    time.sleep(1)
    x = x + 1
    return n*2, x


if __name__ == '__main__':

    p = Pool(4)
    list1 = []
    for i in range(6):
        # result = p.apply_async(learn, args=(2, 0,))   # 异步
        result = p.apply(learn, args=(2, 0,))   # 同步
        print(result)
        list1.append(result)

    p.close()
    p.join()

    for j in list1:
        print(j)    # 同步不需要
        # print(j.get())  # 异步通过get取值

"""
异步=========================
根据Pool的进程数量，我们能得知os.getpid() 能有几个进程数
根据循环次数，能够知道做几次调用,并且返回值必须通过get获得，否则为地址
<multiprocessing.pool.ApplyResult object at 0x000001828A13DBC8>
<multiprocessing.pool.ApplyResult object at 0x000001828A13DCC8>
<multiprocessing.pool.ApplyResult object at 0x000001828A13DDC8>
<multiprocessing.pool.ApplyResult object at 0x000001828A13DE88>
<multiprocessing.pool.ApplyResult object at 0x000001828A13DF08>
<multiprocessing.pool.ApplyResult object at 0x000001828A142048>
we are studying now at 16360-10252
we are studying now at 13772-10252
we are studying now at 11132-10252
we are studying now at 13820-10252
we are studying now at 16360-10252
we are studying now at 13772-10252
(4, 1)
(4, 1)
(4, 1)
(4, 1)
(4, 1)
(4, 1)
同步=======================
we are studying now at 16940-13756
(4, 1)
we are studying now at 16864-13756
(4, 1)
we are studying now at 16796-13756
(4, 1)
we are studying now at 16920-13756
(4, 1)
we are studying now at 16940-13756
(4, 1)
we are studying now at 16864-13756
(4, 1)
(4, 1)
(4, 1)
(4, 1)
(4, 1)
(4, 1)
(4, 1)
"""