Python的多进程

一.进程通信

1.代码：

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()
    while 1:
        #input_=input('>>')
        #conn_b.send(input_)
         conn_b.send([1,2,3,4,5,6,7])  #发送数据给conn_a
         print('main',conn_b.recv())

#  运行结果：
#  A [1, 2, 3, 4, 5, 6, 7]
#  main ['a', 'b', 'c', 'd', 'e']

2.聊天机器人
代码：

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:
            conn.send('没事别打扰我可以嘛~')

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

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

#  运行结果：
#  人说：你好
#  机器人收到：你好
#  我不好~
#  人说：你在干嘛呀？
#  机器人收到：你在干嘛呀？
#  没事别打扰我可以嘛~

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())  # 脚本父进程取出

#  运行结果：
#  8672
#  3580
#  [1, 2, 3, 4]

二.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 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
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]

五、队列（可以进程共享）☆

1.先进先出；get获取不到，一直等待；放一个取一个
2.若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()

"""
运行结果：
GET 100
GET 100
GET 100
GET 100
GET 100
GET 100
GET 100
GET 100
GET 100
GET 100
队列中在5秒之内已经无法获取元素
"""

六、queue对象

1.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()

2.Queue.empty()
如果队列为空，返回 True ，否则返回 False 。
3.Queue.full()
如果队列是满的返回 True ，否则返回 False 。
4.Queue.put(item, block=True, timeout=None)
将 item 放入队列。如果可选参数 block 是 true 并且 timeout 是 None (默认)，则在必要时阻塞至有空闲插槽可用。
5.Queue.get(block=True, timeout=None)
从队列中移除并返回一个项目。如果可选参数 block 是 true 并且 timeout 是 None (默认值)，则在必要时阻塞至项目可得到。

七、进程数据共享（了解）

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["sfr"] = "厉害"
    mydict["weg"] = "美女"
    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)))  # 很牛逼的list

#  运行结果：
#  [0, 1, 2, 3, 4, 11, 22, 33]
#  {'sfr': '厉害', 'weg': '美女'}

十、进程池（了解）