5. 21、python中的进程间通信、线程间通信与生产者消费者模型_笔记
    7. # multiprocessing.Queue
    8. # 进程彼此之间互相隔离，要实现进程间通信（IPC）,
    9. # multiprocessing模块支持两种形式：队列Queue和管道Pipe，这两种方式都是使用消息传递的
    12. # 创建队列的类（底层就是以管道和锁定的方式实现）：
    13. # Queue([maxsize]):创建共享的进程队列，Queue是多进程安全的队列，可以使用Queue实现多进程之间的数据传递。
    14. # 参数介绍：maxsize是队列中允许最大项数，省略则无大小限制。
    16. # Queue介绍方法
    17. # q.get_nowait():同q.get(False)
    18. # q.put_nowait():同q.put(False)
    19. # q.empty():调用此方法时q为空则返回True，该结果不可靠，比如在返回True的过程中，如果队列中又加入了项目。
    20. # q.full()：调用此方法时q已满则返回True，该结果不可靠，比如在返回True的过程中，如果队列中的项目被取走。
    21. # q.qsize():返回队列中目前项目的正确数量，结果也不可靠，理由同上.
    23. # pipe管道通信
    25. # Pipe方法返回(conn1, conn2)代表一个管道的两个端。
    26. # Pipe方法有duplex参数:duplex 为 True(默认值)，那么这个管道是全双工模式，也就是说conn1和conn2均可收发。
    27. # duplex 为 False，conn1只负责接受消息，conn2只负责发送消息。前收后发
    29. # send和recv方法分别是发送和接收消息的方法。
    30. # 在全双工模式下，可以调用conn1.send发送消息，conn1.recv接收消息。
    31. # 如果没有消息可接收，recv方法会一直阻塞。如果管道已经被关闭，那么recv方法会抛出EOFError
    33. # -*- coding: utf-8 -*-
    34. __author__ = 'dongfangyao'
    35. __date__ = '2018/1/17 下午9:40'
    36. __product__ = 'PyCharm'
    37. __filename__ = 'processing3'
    38. import time
    39. import multiprocessing
    41. # 进程间通信  发消息 数据
    42. # 队列 管道 Queue  Pipe
    44. # put  get
    46. # queue实现跨进程通信
    49. # def put(q):
    50. #     for value in ['a', 'b', 'c']:
    51. #         print('发送 %s 到queue中。。。'%value)
    52. #         q.put(value)
    53. #         time.sleep(2)
    54. #
    55. #
    56. # def get(q):
    57. #     while True:
    58. #         value = q.get(True)
    59. #         print('从queue取到数据：%s !'%value)
    60. #
    61. #
    62. # q = multiprocessing.Queue()
    63. #
    64. # pwrite = multiprocessing.Process(target=put, args=(q, ))
    65. # pread = multiprocessing.Process(target=get, args=(q, ))
    66. #
    67. # pwrite.start()
    68. # pread.start()
    69. #
    70. # pwrite.join()
    71. # pread.terminate()
    72. #
    73. # print('父进程结束')
    76. # Pipe管道的方式 跨进程通信
    78. def put(p):
    79.    for value in ['a', 'b', 'c']:
    80.        print('发送 %s 到pipe中。。。'%value)
    81.        p[1].send(value)
    82.        # q.put(value)
    83.        time.sleep(2)
    86. def get(p):
    87.    while True:
    88.        # value = q.get(True)
    89.        value = p[0].recv()
    90.        print('从pipe取到数据：%s !'%value)
    92. # Pipe()方法返回（conn1,conn2） 代表是一个管道的两端
    93. # 前收 后发
    94. p = multiprocessing.Pipe(duplex=False)
    96. pwrite = multiprocessing.Process(target=put, args=(p, ))
    97. pread = multiprocessing.Process(target=get, args=(p, ))
    99. pwrite.start()
    100. pread.start()
    102. pwrite.join()
    103. pread.terminate()
    105. print('父进程结束')
    108. 复制代码
    110. # 1、queue.Queue是进程内非阻塞队列 其实就是线程之间的通信
    111. #  2、multiprocess.Queue是跨进程通信队列。
    114. # 队列：先进先出 后进后出
    115. # 生成者消费者模型  是通过线程来实现的
    117. # -*- coding: utf-8 -*-
    118. __author__ = 'dongfangyao'
    119. __date__ = '2018/1/17 下午9:54'
    120. __product__ = 'PyCharm'
    121. __filename__ = 'threading3'
    122. import time
    123. import threading
    124. import queue
    126. # 线程间通信 队列
    127. # queue.Queue()
    128. # 操作系统课程  生产者与消费者模式
    130. q = queue.Queue(maxsize=10)
    132. def producer(name):
    133.    count = 1
    134.    while True:
    135.        q.put('骨头%s'%count)
    136.        print('%s生产了骨头%s'%(name, count))
    137.        count+=1
    138.        time.sleep(0.5)
    141. def consumer(name):
    142.    while True:
    143.        print('[%s]消费[%s]并且吃了它...'%(name, q.get()))
    144.        time.sleep(2)
    147. p = threading.Thread(target=producer, args=('dfy', ))
    148. c1 = threading.Thread(target=consumer, args=('zhangsan', ))
    149. c2 = threading.Thread(target=consumer, args=('lisi', ))
    151. p.start()
    152. c1.start()
    153. c2.start()
    156. 复制代码