进程通信

Posted 2021-06-08 管控念头

import multiprocessing, time

\'\'\'Process类其它方法及属性\'\'\'
# class MyProcess(multiprocessing.Process):
#  def __init__(self, city):
#     super(MyProcess, self).__init__(name=\'进程\')
#     self.city = city
#
#  def run(self):
#     print(self.name) # 进程名，默认是类名
#     print(self.is_alive()) # 进程是否在运行
#     print(self.pid) # 进程ID，等于os.getpid()
#
# if __name__ == \'__main__\':
#  l = []
#  for p in range(4):
#     p = MyProcess(\'China\')
#     p.start()
#     l.append(p)
#  for p in l:
#     p.join()


\'\'\'进程间的通信\'\'\'
# 进程队列Queue
# def foo(q):
#  q.put(1) # 子进程运行此函数，队列q传了过来，所以可进行put操作
#  q.put(\'alex\')
#  q.put({\'name\': \'mike\'})
#
# def func(q):
#  time.sleep(3)
#  while True:
#     try:
#        data = q.get_nowait()
#        print(data)
#     except Exception:
#        break
#
# if __name__ == \'__main__\':
#  q = multiprocessing.Queue() # multiprocessing模块下的Queue()类
#  p = multiprocessing.Process(target=foo, args=(q,)) # 不同进程间通信需要把队列q当作参数传输
#  p.start()
#  p2 = multiprocessing.Process(target=foo, args=(q,)) # 不同进程间通信需要把队列q当作参数传输
#  p2.start()
#  p1 = multiprocessing.Process(target=func, args=(q,))
#  p1.start()
#  p1.join()
#  print(\'end...\')
# 线程是在进程里面，队列或全局变量都可以共享；而进程各个都是独立，想要通信数据，那么必须要有一个传输


# 管道Pipe，Pipe()函数返回一个由管道连接的连接对象，默认情况下是双工（双向）。返回的两个连接对象 Pipe() 表示管道的两端。每个连接对象都有
# send() 和 recv() 方法（相互之间的）。请注意，如果两个进程（或线程）同时尝试读取或写入管道的同一端，则管道中的数据可能会损坏。当然，
# 在不同进程中同时使用管道的不同端的情况下不存在损坏的风险。
# def foo(conn):
#  conn.send([42, None, \'hello\'])
#  # send(obj)将一个对象发送到连接的另一端，可以用 recv() 读取。发送的对象必须是可以序列化的，过大的对象 ( 接近 32MiB+ ，这个值取决于操作系统 ) 有可能引发ValueError异常。
#  print(conn.recv())
#  # recv()返回一个由另一端使用 send() 发送的对象。该方法会一直阻塞直到接收到对象。如果对端关闭了连接或者没有东西可接收，将抛出 EOFError 异常。
#  conn.close()
#  # close()关闭连接对象。当连接对象被垃圾回收时会自动调用。
#
# if __name__ == \'__main__\':
#  parent_conn, child_conn = multiprocessing.Pipe()
#  # 连接（Connection）对象,Connection对象允许收发可以序列化的对象或字符串。它们可以看作面向消息的连接套接字。通常使用Pipe创建Connection对象。
#  p = multiprocessing.Process(target=foo, args=(child_conn,))
#  p.start()
#  print(parent_conn.recv())
#  parent_conn.send({\'name\':\'alex\'})
#  p.join()
# 管道和队列(进程之间的两种通信通道，并非共享数据(一方修改另一方也会有相应变化))，使用多进程时，一般使用消息机制实现进程间通信，尽可能避免使用同步原语，例如锁。
# 消息机制包含：Pipe()(可以用于在两个进程间传递消息)，以及队列(能够在多个生产者和消费者之间通信)。


# multiprocessing.Manager()管理器，管理器提供了一种创建共享数据的方法，从而可以在不同进程中共享，甚至可以通过网络跨机器共享数据。管理器维护
# 一个用于管理共享对象的服务。其他进程可以通过代理访问这些共享对象。
def foo(d, l, n):
   d[n] = \'1\'
   l.append(n)
   d[\'2\'] = 2
   # print(\'son process:\', id(d), id(l))

if __name__ == \'__main__\':
   with multiprocessing.Manager() as manager:
      d = manager.dict() # 创建一个共享的 dict 对象并返回它的代理
      l = manager.list() # 创建一个共享的 list 对象并返回它的代理
      num = manager.Namespace() # 命名空间对象没有公共方法，但是拥有可写的属性。直接print会显示所有属性的值。
      num.x = 20
      l1 = []
      for t in range(10):
         p = multiprocessing.Process(target=foo, args=(d, l, t))
         p.start()
         l1.append(p)
      for i in l1:
         i.join()
      print(d)
      print(l)
      print(num)