Python——多进程

一、multiprocessing

import multiprocessing
import os

def info(title):
    print(title)
    print(__name__)
    print('father', os.getppid())
    print('self', os.getpid())
    print('--------')



if __name__ == "__main__": # 除了创建的子进程和子进程调用函数，其他的都是脚本主进程
    # info('hello')
    # 创建一个子进程调用函数
    P = multiprocessing.Process(target=info,args=('hello python',))
    P.start()
    P.join() # 和多线程一样，也是等待的意思
    print('hello word') # 若没有join则会独立运行

二、join

import multiprocessing
import os
import time


def info(title):
    print(title)
    time.sleep(2)
    print(__name__)
    print('father', os.getppid())
    print('self', os.getpid())
    print('--------')


if __name__ == "__main__":
    p1 = multiprocessing.Process(target=info,args=('A1',))
    p2 = multiprocessing.Process(target=info, args=('A2',))
    p3 = multiprocessing.Process(target=info, args=('A3',))
    p1.start()
    p2.start()
    p3.start()
    p1.join()
    p2.join()
    p3.join()
    # 这里的join只是为了卡住主进程，使得三个进程都执行完毕再执行print
    # 这里很重要，以后多进程扫描文件需要完全等待几个进程全部执行完毕在汇总
    print('all over')
    '''
    轮流执行
    p1.start()
    p1.join()
    p2.start()
    p2.join()
    p3.start()
    p3.join()
    '''

三、Rlock

import os
import multiprocessing
import time


# 多进程，并发，可能乱序并发执行（主要看系统如何处理）
# 多进程加锁，挨个执行,也可能是乱序

def showdata(lock, i):
    with lock:
        print(multiprocessing.current_process().name)
        time.sleep(2)
        print(i)


if __name__ == "__main__":
    lock = multiprocessing.RLock()  # 创建锁
    for num in range(10):
        multiprocessing.Process(target=showdata, args=(lock, num)).start()

import multiprocessing



def A(lock, i):
    print(i)

if __name__ == "__main__":
    lock = multiprocessing.RLock()  
    for I in range(10):
        A(lock,i)

"""
0
1
2
3
4
5
6
7
8
9
"""

进程是一个独立的状态，各个进程之间毫不相关

import multiprocessing



def A(lock, i):
    with lock:
        print(i)


if __name__ == "__main__":
    lock = multiprocessing.RLock() 
    process_list = [] 
    for i in range(10):
        p = multiprocessing.Process(target=A, args=(lock, i))
        p.start()
        process_list.append(p)

    for p in process_list:
        p.join()
"""
0
1
2
3
4
5
6
7
8
9
"""

四、进程通信

import multiprocessing
import os


def func(conn):  # conn表示管道类型
    print('func',os.getpid(), conn.recv())  # 收到的数据
    conn.send(['a', 'b', 'c', 'd', 'e'])  # 发送的数据
    conn.close()  # 关闭

if __name__ == "__main__":
    conn_a, conn_b = multiprocessing.Pipe()  # 创建一个管道，有两个口

    # print(id(conn_a),id(conn_b))
    # print(type(conn_a), type(conn_b)) #multiprocessing.connection.Connection链接，意思就是连接口

    # 相当于在进程中conn_a.send(['a','b','c','d','e'])，发送给conn_b
    p = multiprocessing.Process(target=func, args=(conn_a,)).start()
    conn_b.send([1, 2, 3, 4, 5, 6, 7])  # 发送数据给conn_a
    print('mian',os.getpid(), conn_b.recv())

"""
func 10212 [1, 2, 3, 4, 5, 6, 7]
mian 10024 ['a', 'b', 'c', 'd', 'e']
"""

import multiprocessing


def A(conn):  
    conn.send(['a', 'b', 'c', 'd', 'e'])  
    print('A',conn.recv())
    conn.close()  


if __name__ == "__main__":
    conn_a, conn_b = multiprocessing.Pipe()  

    p = multiprocessing.Process(target=A, args=(conn_a,))
    p.start()
    conn_b.send([1, 2, 3, 4, 5, 6, 7])  
    print('mian', conn_b.recv())

"""
A [1, 2, 3, 4, 5, 6, 7]
mian ['a', 'b', 'c', 'd', 'e']
"""

import multiprocessing


def A(conn):   
    print('A',conn.recv())
    #conn.close()  


if __name__ == "__main__":
    conn_a, conn_b = multiprocessing.Pipe()  
    p = multiprocessing.Process(target=A, args=(conn_a,))
    p.start()
    while 1:
        input_ = input('>>')
        conn_b.send(input_) 

练习：类似于聊天机器人的一个对话系统

import multiprocessing


def M(conn):
    while 1:
        recv_ = conn.recv()
        print('机器人收到：%s'%recv_)
        if recv_ == '你好！':
            conn.send('你好！')
        elif recv_ == '今天天气怎么样？':
            conn.send('今天天气不错！')
        elif recv_ == '拜拜！':
            conn.send('很期待下次你找我~~')
        else:
            print('我没听清你说什么奥')

def P(conn):
    y = 'y'
    while y != 'n':
        input_ = input('人说：')
        conn.send(input_)
        print(conn.recv())


if __name__ == "__main__":
    conn_M,conn_P = multiprocessing.Pipe()
    p_M = multiprocessing.Process(target = M,args = (conn_M,))
    p_M.start()
    P(conn_P)

"""
人说：你好！
机器人收到：你好！
你好！
人说：今天天气怎么样？
机器人收到：今天天气怎么样？
今天天气不错！
人说：哈哈
机器人收到：哈哈
我没听清你说什么奥
"""

五、全局变量（进程不可以共享）

import multiprocessing
import os
data = []

def List():
    global data
    data.append(1)
    data.append(2)
    data.append(3)
    print('p',os.getpid(),data)


if __name__ == '__main__':
    p = multiprocessing.Process(target=List,args=()).start()  # 子进程
    data.append('a')  # 脚本主进程
    data.append('b')
    data.append('c')
    print('main',os.getpid(),data)

'''
main 276 ['a', 'b', 'c']
p 5788 [1, 2, 3]
'''

六、队列（可以进程共享）

重要！！！

import multiprocessing
import os

queue = multiprocessing.Queue()
# 注意队列只能单向，要么是父进程插入子进程取出，要么是子进程插入父进程取出

def func(myq):
    print(os.getpid())
    myq.put([1, 2, 3, 4])  # 子进程插入


if __name__ == '__main__':
    print(os.getpid())
    # queue.put(['a','b'])  # 这里若是脚本父进程先插入了，子进程就没法再插入了
    p = multiprocessing.Process(target=func, args=(queue,))
    p.start()
    print(queue.get())  # 脚本父进程取出

"""
9700
3236
[1, 2, 3, 4]
"""

1、性质：先进先出；get获取不到，一直等待；放一个取一个

import multiprocessing

def PUT(q):
    q.put(100)

def GET(q):
    print('GET',q.get())
    

if __name__ == '__main__':
    q = multiprocessing.Queue()
    p1 = multiprocessing.Process(target=PUT, args=(q,))
    p2 = multiprocessing.Process(target=GET, args=(q,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()

"""
GET 100
"""

import multiprocessing

def PUT(q):
    for i in range(10):
        q.put(100)

def GET(q):
    print('GET',q.get())
    

if __name__ == '__main__':
    q = multiprocessing.Queue()
    p1 = multiprocessing.Process(target=PUT, args=(q,))
    p2 = multiprocessing.Process(target=GET, args=(q,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()

注：运行完卡住不动，应想办法关掉

import multiprocessing
import time

def PUT(q):
    for i in range(10):
        time.sleep(1)
        q.put(100)

def GET(q):
    while 1:
        print('GET',q.get(timeout = 5))
    

if __name__ == '__main__':
    q = multiprocessing.Queue()
    p1 = multiprocessing.Process(target=PUT, args=(q,))
    p2 = multiprocessing.Process(target=GET, args=(q,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()

若5秒没有进入，则全部崩掉，之前的也会没有，这显然不行，我们可以用try…except解决（一定要加break，不然会停不下来，输出完成后一直输出结束语句）

import multiprocessing
import time

def PUT(q):
    for i in range(10):
        time.sleep(1)
        q.put(100)

def GET(q):
    while 1:
        try:
            print('GET',q.get(timeout = 5))
        except:
            print('队列中在5秒之内已经无法获取元素')
            break
    

if __name__ == '__main__':
    q = multiprocessing.Queue()
    p1 = multiprocessing.Process(target=PUT, args=(q,))
    p2 = multiprocessing.Process(target=GET, args=(q,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()

七、queue对象

Queue.qsize()
返回队列的大致大小。注意，qsize() > 0 不保证后续的 get() 不被阻塞，qsize() < maxsize 也不保证 put() 不被阻塞。
注：maxsize=5表示的是五个空间大小，而不是只能放五个

import multiprocessing
import time

def PUT(q):
    for i in range(10):
        time.sleep(1)
        q.put(100)

def GET(q):
    pass
    

if __name__ == '__main__':
    q = multiprocessing.Queue(maxsize=5)
    p1 = multiprocessing.Process(target=PUT, args=(q,))
    p1.start()
    p1.join()

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.get(block=True, timeout=None)
从队列中移除并返回一个项目。如果可选参数 block 是 true 并且 timeout 是 None (默认值)，则在必要时阻塞至项目可得到。如果 timeout 是个正数，将最多阻塞 timeout 秒，如果在这段时间内项目不能得到，将引发 Empty 异常。反之 (block 是 false) , 如果一个项目立即可得到，则返回一个项目，否则引发 Empty 异常 (这种情况下，timeout 将被忽略)。

八、进程数据共享

import multiprocessing


def func(num):
    num.value = 10


if __name__ == '__main__':
    # multiprocessing.Value可以在不同进程之间共享数据
    num = multiprocessing.Value('d', 1)  # double float
    print(num.value)  # 单单num返回的结果 Synchronized wrapper for c_double(1.0)
    p = multiprocessing.Process(target=func, args=(num,))
    p.start()
    p.join()
    print(num.value)

"""
1.0
10.0
"""

Value(typecode_or_type, *args[, lock])
Value函数返回一个shared memory包装类，其中包含一个ctypes对象
typecode_or_type typecode列表如下

Type code C Type Python Type
‘c’ char character
‘b’ signed char int
‘B’ unsigned char int
‘u’ Py_UNICODE Unicode character
‘h’ signed short int
‘H’ unsigned short int
‘i’ signed int int
‘I’ unsigned int long
‘l’ signed long int
‘L’ unsigned long long
‘f’ float float
‘d’ double float

九、进程列表数据共享

import multiprocessing


def func(num):
    num[2] = 9999


if __name__ == '__main__':
    # 不同进程之间实现数组共享
    num = multiprocessing.Array('i', [1, 2, 3, 4, 5, 6])  # i代表int类型
    print(num[:])
    p = multiprocessing.Process(target=func, args=(num,))
    p.start()
    p.join()
    print(num[:])

"""
[1, 2, 3, 4, 5, 6]
[1, 2, 9999, 4, 5, 6]
"""

十一、进程字典列表共享

import multiprocessing


def func(mydict, mylist):
    mydict["aaa"] = "bbb"
    mydict["ccc"] = "ddd"
    mylist.append(11)
    mylist.append(22)
    mylist.append(33)


if __name__ == "__main__":
    # with multiprocessing.Manager() as MG:
    #     mydict=MG.dict()
    #     mylist=MG.list(range(5))
    mydict = multiprocessing.Manager().dict()
                                        # [0,1,2,3,4]
    mylist = multiprocessing.Manager().list(range(5))

    p = multiprocessing.Process(target=func, args=(mydict, mylist))
    p.start()
    p.join()

    print(mylist)
    print(mydict)
# print(list(range(5)))  

"""
[0, 1, 2, 3, 4, 11, 22, 33]
{'aaa': 'bbb', 'ccc': 'ddd'}
"""

十二、进程池

知道即可，不建议用

from multiprocessing import Pool
import os
import time

def love(*args):
    print('love start',os.getpid(),args)
    a = time.time()
    time.sleep(2)
    print('love start',os.getpid(),args,time.time() - a)


if __name__ == "__main__":
    print('won won',os.getpid())
    #构造进程池，默认参数为系统CPU核心数
    pool = Pool
    #往池子里加任务
    pool.apply_async(love,args=('hhl',18))
    pool.apply_async(love,args=('red',18))
    pool.apply_async(love,args=('yellow',18))
    pool.apply_async(love,args=('green',18))
    pool.apply_async(love,args=('blue',18))
    #启动任务之前一定要先关机，启动之后无法加入新任务
    #进程自动用以join方式启动，先堵塞当前进程，池子中所有任务都执行完成才会执行当前新任务
    #相当于普通进程start() + join()
    pool.join()
    print("**************")

八、九、十、十一、十二了解即可