# -*- coding: utf-8 -*-

"""

多进程  共享  队列 multiprocessing.Process

逻辑:

   一个进程往队列写数据，一个进程从读写读数据

   写进程完了后，主进程强行结束读进程

使用:

    1. 创建队列 q = multiprocessing.Queue() ,默认无限大小,可以指定大小

    2. 把队列 q 当参数传给 子进程 执行代码， 猜测应该不能通过全局变量的方式访问

    3. 在子进程中读写队列数据   q.put(<data>)  q.get()

参考:

方法

'cancel_join_thread', 'close', 'empty', 'full', 'get', 'get_nowait', 'join_thread', 'put', 'put_nowait', 'qsize'

"""

from multiprocessing import Queue, Process

import time

def write(q):

    for i in ['a','b','c','d']:

        time.sleep(2)

        q.put(i)

        print ('put {0} to queue'.format(i))

def read(q):

    while 1:

        time.sleep(2)

        result = q.get()

        print ("get {0} from queue".format(result))

def main():

    q = Queue()

    pw = Process(target=write, args=(q,))

    pr = Process(target=read,  args=(q,))

    pw.start()

    pr.start()

    pw.join()

    pr.terminate()  # 强行终止读进程

if __name__ == '__main__':

    main()

"""

Out:

put a to queue

get a from queue

put b to queue

get b from queue

put c to queue

get c from queue

put d to queue

get d from queue

"""

# -*- coding: utf-8 -*-

"""

多进程 生产者 消费者模型，使用队列实现 multiprocessing.Queue

逻辑:

    1个生产者，1个消费者在2个不同的进程中操作同一个队列

    生产者的速度是消费者的3倍

"""

import multiprocessing

import random

import time

# 生产者

class producer(multiprocessing.Process):

    def __init__(self, queue):

        multiprocessing.Process.__init__(self)  # 父类构造

        self.queue = queue

    def run(self):

        for i in range(10):

            item = random.randint(0, 256)

            #  往队列写数据

            self.queue.put(item)

            print("Process Producer: item %d appended to queue %s " \

                  %(item, self.name))

            time.sleep(1)

            print("The size of queue is %s" \

                  % self.queue.qsize())

# 消费者

class consumer(multiprocessing.Process):

    def __init__(self, queue):

        multiprocessing.Process.__init__(self)  # 父类构造

        self.queue = queue

    def run(self):

        while True:

            if (self.queue.empty()):

                print("the queue is empty")

                break

            else:

                time.sleep(2)

                # 从队列读取数据，队列为空会阻塞，这做了非空判断，只有一个进程读，不会阻塞

                item = self.queue.get()

                print("Process Consumer: item %d poped from by %s " \

                      % (item, self.name))

                time.sleep(1)

if __name__ == '__main__':

    #  多进程共享对列

    queue = multiprocessing.Queue()

    ## 启动生产者、消费者

    process_producer = producer(queue)

    process_consumer = consumer(queue)

    process_producer.start()

    process_consumer.start()

    process_producer.join()

    process_consumer.join()

"""

Out:

the queue is empty

Process Producer: item 225 appended to queue producer-1

The size of queue is 1

Process Producer: item 101 appended to queue producer-1

The size of queue is 2

Process Producer: item 50 appended to queue producer-1

The size of queue is 3

Process Producer: item 217 appended to queue producer-1

The size of queue is 4

Process Producer: item 75 appended to queue producer-1

The size of queue is 5

Process Producer: item 45 appended to queue producer-1

The size of queue is 6

Process Producer: item 19 appended to queue producer-1

The size of queue is 7

Process Producer: item 157 appended to queue producer-1

The size of queue is 8

Process Producer: item 127 appended to queue producer-1

The size of queue is 9

Process Producer: item 223 appended to queue producer-1

The size of queue is 10

"""