被python折磨的第六天 --- 多进程与多线程

2019.08.21

进程的概念

进程： 一个正在执行的程序
● 第一，进程是一个实体。每一个进程都有它自己独立的地址空间，，一般情况下，包括文本区域（text region）、数据区域（data region）和堆栈（stack region）。文本区域存储处理器执行的代码；数据区域存储变量和进程执行期间使用的动态分配的内存；堆栈区域存储着活动过程调用的指令和本地变量。
● 第二，进程是一个“执行中的程序”。程序是一个没有生命的实体，只有处理器赋予程序生命时（操作系统执行之），它才能成为一个活动的实体，我们称其为进程。
并发与并行区别
● 并行是指两个或者多个事件在同一时刻发生；而并发是指两个或多个事件在同一时间间隔内发生。
并行：

并发：

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])      #发送数据给conn_a
    print('main',conn_b.recv())

(base) C:\Users\Administrator>F:/install/Anaconda/python.exe d:/VScode/Untitled-11.py
A: [1, 2, 3, 4, 5, 6, 7]
main ['a', 'b', 'c', 'd', 'e']

A只负责接收，B只负责发送,单方面无限循环

import multiprocessing

def A(conn):
    while 1:
        print('A',conn.recv())     # 收到的数据

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_a

(base) C:\Users\Administrator>F:/install/Anaconda/python.exe d:/VScode/Untitled-11.py
>>987654321
A 987654321
>>kdffsg
A kdffsg
......

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

import os
import multiprocessing

def R(conn):
    while 1:
        recv_ = conn.recv()
        print('机器人收到：%s'%recv_)     # 收到的数据 
        if recv_ == '你好':
            conn.send('你也好')
        elif recv_ == '今天天气怎么样':
            conn.send('I dont known') 
        elif recv_ == '我美吗~':
            conn.send('You are beautiful') 
        else:
            conn.send('我们交个朋友吧！')    

def P(conn) :
    y = 'y'
    while y != 'n':
        input_ = input('人说：')
        conn.send(input_)
        os.system('say %s'%conn.recv())


if __name__ == "__main__":
    conn_R,conn_P = multiprocessing.Pipe()
    p_R = multiprocessing.Process(target=R,args=(conn_R,))
    p_R.start()
    P(conn_P)

queue —一个同步的队列类

Queue.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.put_nowait(item)
相当于 put(item, False) 。
Queue.get(block=True, timeout=None)
从队列中移除并返回一个项目。如果可选参数 block 是 true 并且 timeout 是 None (默认值)，则在必要时阻塞至项目可得到。如果 timeout 是个正数，将最多阻塞 timeout 秒，如果在这段时间内项目不能得到，将引发 Empty 异常。反之 (block 是 false) , 如果一个项目立即可得到，则返回一个项目，否则引发 Empty 异常 (这种情况下，timeout 将被忽略)。
Queue.get_nowait()
相当于 get(False)
Queue.task_done()
表示前面排队的任务已经被完成。被队列的消费者线程使用。每个 get() 被用于获取一个任务， 后续调用 task_done() 告诉队列，该任务的处理已经完成。如果 join() 当前正在阻塞，在所有条目都被处理后，将解除阻塞(意味着每个 put() 进队列条目的 task_done() 都被收到)。如果被调用的次数多于放入队列中的项目数量，将引发 ValueError 异常 。

timeout（）用法

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(maxsize=5)
    p1 = multiprocessing.Process(target=PUT,args=(q,))
    p2 = multiprocessing.Process(target=GET,args=(q,))
    p1.start()
    p2.start()