进程常用管理

1.进程间通信—采用管道

import time
from multiprocessing import Process,Pipe

def func(conn2):
    # c1,c2 = con
    # c1.close()#主进程用conn1发送数据,子进程要用对应的conn2接受,所以讲conn1关闭,不关闭程序会阻塞
    while 1:
        try:#异常处理,出现异常退出
            a = conn2.recv()
            print(a)#将conn2接受的数据打印
        except:#说明素有数据已经全部接受,进程会抛出异常
            break
    # print(conn2.recv())

if __name__ == '__main__':
    conn1,conn2 = Pipe()#开启管道
    p = Process(target=func, args=(conn2,))#将管道的两个返回值以元组形式传给子进程
    # p = Process(target=func, args=((conn1,conn2),))#将管道的两个返回值以元组形式传给子进程
    p.start()
    # conn2.close()#用conn1发送数据,conn2不用,将其关闭
    # for i in range(10):
    n = 1
    while True:
        time.sleep(1)
        conn1.send(n)
        n+=1

进程间通信—采用队列

from multiprocessing import Process,Queue
import time,random,os
def consumer(q):
    while True:
        res=q.get()
        time.sleep(random.randint(1,3))
        print('\033[45m%s 吃 %s\033[0m' %(os.getpid(),res))

def producer(q):
    for i in range(10):
        time.sleep(random.randint(1,3))
        res='包子%s' %i
        q.put(res)
        print('\033[44m%s 生产了 %s\033[0m' %(os.getpid(),res))

if __name__ == '__main__':
    q=Queue()
    #生产者们:即厨师们
    p1=Process(target=producer,args=(q,))
    #消费者们:即吃货们
    c1=Process(target=consumer,args=(q,))

    #开始
    p1.start()
    c1.start()
    print('主')

2.进程同步（并行）

Barrier：将程序分成几个阶段，适用于有些进程必须在某些特性进程之后执行，处于Barrier之后的代码不能同处于Barrier之前的代码并行

from multiprocessing import Process, Lock,Barrier
from mmw_radar_data import  mmw_radar_data
from camera import capture_image
# lock = Lock()  # 创建一个共享锁实例
 # create a barrier and lock.
synchronizer = Barrier(2)
serializer = Lock()
print('start camera')# 拍照记录
Process(name='camera', target=capture_image, args=(synchronizer, serializer)).start()
print('start radar') #雷达记录
Process(name='radar', target=mmw_radar_data, args=(synchronizer, serializer)).start()

3.定时器（只能线程使用）

import threading
import time

def hello(name):
    # print ("hello %s" ) % name
    print(name)
    global timer
    threading.Timer(0.5, hello, ("Hawk",)).start()


if __name__ == "__main__":
    threading.Timer(0.5, hello, ("Hawk",)).start()   ##每隔两秒调用函数hello

eg.拍照与存储

import cv2
import time
import os

import sys

import numpy as np
import threading
pic_list = []
def capture_image(synchronizer, serializer):
    global pic_list
    cap = cv2.VideoCapture(0)
    # fps = FPS().start()
    cap.set(3, 640)
    cap.set(4, 480)
    # cap.set(5, 10)
    picfolder = camera_makedir()
    try:
      threading.Timer(0.5, write_image, (picfolder,pic_list)).start()
      while True:
        ret, img = cap.read()
        start_time = time.time()
        if img is not None:
            [first, second] = str(start_time).split('.')
            second = second.ljust(7, '0')
            name = first + '.' + second + '.jpg'
            data = {'name': name, 'image': img}
            pic_list.append(data)
            if len(pic_list) > 20:
                pic_list.pop(0)

            print('curr pic time %f' % start_time)
        else:
            print('camera failure')
    except KeyboardInterrupt:
        return

def write_image(picfolder,pic_list):
    threading.Timer(0.5, write_image, (picfolder,pic_list)).start()
    if len(pic_list) > 0:
        data = pic_list[-1]
        cv2.imwrite(os.path.join(picfolder, data['name']), data['image'])

def camera_makedir():
    root_path = os.path.join(sys.path[0],
                             time.strftime('%Y-%m-%d-%H-%M-%S', time.localtime(time.time())))
    if not os.path.exists(root_path):
        os.makedirs(root_path)
    # picfolder = root_path + '/picture'
    # os.makedirs(picfolder)
    return root_path


if __name__ == "__main__":
     print()

4.supervisorctl启动需要指定，用户权限