Study python Day06

进程
创建多进程:需要用到muiltprocessing库，其中的Process类跟threading模块的Thread类很相似
方法一:直接使用Process

from multiprocessing import Process  

def show(name):
    print("Process name is " + name)

if __name__ == "__main__": 
    proc = Process(target=show, args=('subprocess',))  
    proc.start()  
    proc.join()


结果:Process name is subprocess

方法二：继承Process来自定义进程类，重写run方法

from multiprocessing import Process
import time

class MyProcess(Process):
    def __init__(self, name):
        super(MyProcess, self).__init__()
        self.name = name

    def run(self):
        print('process name :' + str(self.name))
        time.sleep(1)

if __name__ == '__main__':
    for i in range(3):
        p = MyProcess(i)
        p.start()
    for i in range(3):
        p.join()

B接收A发送的消息

import multiprocessing
def A(conn):
    conn.send(['a','b','c','d'])
    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])
    print('main',conn_b,recv())

结果:A [1, 2, 3, 4, 5, 6]

键盘输入,接受一次消息

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()
    input_=input('>>')
    conn_b.send(input_)
    # print('main',conn_b,recv())


结果:>>lalala
	A lalala

键盘输入,接收多次消息

import multiprocessing
def A(conn):
    while 1:
        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_)
    print('main',conn_b,recv())



结果:>>hei
		A hei
		>>lalala
		A lalala

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

import os
import multiprocessing

def M(conn):
    while 1:
        recv_=conn.recv()
        print('机器人收到:%s'%recv_)
        if recv_=="你好":
            conn.send('你好')
        elif recv_=="不想学python的第六天":
            conn.send('好巧哦,我也是')
        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_M,conn_P=multiprocessing.Pipe()
    p_M=multiprocessing.Process(target=M,args=(conn_M,))
    p_M.start()
    P(conn_P)

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

Queue.join()
阻塞至队列中所有的元素都被接收和处理完毕。

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

并发与并行区别
● 并行是指两个或者多个事件在同一时刻发生；而并发是指两个或多个事件在同一时间间隔内发生。
并行：

并发：