2、自定义进程类：需要继承Process类

     　　自定义类的时候必须注意的事项：

          　　第一，必须继承Process类的构造方法

         　　 第二，必须重写Process类的run（）方法

          　　第三，不能用实例化对象直接调用run（）方法，而是调用start（）方法

          　　第四，在进程改变实例化对象的数据时，这个数据是被隔离的，即改变数据不成功

　　3、进程间的通信

          　　像之前改变数据，就要使用到进程间的通信，可以使用multiprocessing模块的Queue类来实现进程间的通信

          　　Queue的常用方法：

               　　qsize(): 返回当前队列包含的消息（数据）数量

               　　empty():如果队列为空，返回True，否则False

               　　full():如果队列满了，返回True，否则False

               　　get() 或者 put()分别时阻塞式获取 或者 阻塞式存储队列的一条消息（数据），然后获取 或者 添加这条消息，如果队列为空 或者 队列满了，在运行的过程阻塞

               　　get_nowait() 或者 put_nowait()分别时非阻塞式获取 或者 非阻塞式存储队列的一条消息（数据），然后移除 和 添加这条消息，如果队列为空 或者 队列满了，会抛出相应的异常

# 自定义进程类

class ProcessClass(Process):

    g_num = 100

    def __init__(self, interval, q):

        # 这行代码必须添加上

        super().__init__()

        self.interval = interval

        self.result = "初始化"

        # 初始化一个队列实例化对象

        self.q = q

    def run(self):

        global g_num

        g_num = 120

        print("子进程{}，开始执行，父进程为{}".format(os.getpid(), os.getppid()))

        start = time.time()

        time.sleep(self.interval)

        stop = time.time()

        print("{}执行结束，耗时{:0.2f}秒".format(os.getpid(), stop-start))

        self.result = "运行之后的结果"

        # 将消息（数据）添加到队列中

        self.q.put(g_num)

        self.q.put(self.result)

    def get_data(self):

        return self.result

if __name__ == "__main__":

    # 初始化一个队列实例化对象，参数为队列的长度

    queues = Queue(5)

    print("当前进程{}".format(os.getpid()))

    p = ProcessClass(2, queues)

    t_start = time.time()

    p.start()

    p.join()

    t_stop = time.time()

    # 数据隔离

    print("子进程 任务 运行结果：", p.get_data())   # -----> 初始化 数据未改变

    print(ProcessClass.g_num)  # ------>100  数据未改变

    print("子进程 任务 运行结果：", queues.get())  # -----> 120 数据未改变

    print("子进程 任务 运行结果：", queues.get())  # -----> 运行之后的结果 数据未改变

    print("(%s)执行结束，耗时%0.2f" % (os.getpid(), t_stop - t_start))

 

4、进程池：

          如果进程有成千上万个，手动创建进程的工作量巨大，这个时候应该用到multiprocessing模块中的Pool类

          这个类下有几个方法比较常用：

          apply_async(func[, args[, kwds]]) ：使用非阻塞方式调用func（并行执行 ，堵塞方式必须等待上一个进程退出才能执行下一个进程），args为传递给 func的参数列表，kwds为传递给func的关键字参数列表；

          apply(func[, args[, kwds]])：使用阻塞方式调用func  close()：关闭Pool，使其不再接受新的任务； 

           terminate()：不管任务是否完成，立即终止；

          join()：主进程阻塞，等待子进程的退出， 必须在close或terminate之后使用

主要实例：

# 进程池

def worker(msg):

    start = time.time()

    print("{}开始执行，进程号为{}".format(msg, os.getpid()))

    # random.random()生成0~1之间的随机数

    time.sleep(random.random()*3)

    # time.sleep(3)

    stop = time.time()

    print(msg, "执行完毕，耗时{:.2f}".format(stop-start))

if __name__ == "__main__":

    # 定义一个进程池，最大数为3

    po = Pool(3)

    for i in range(10):

        # 非阻塞式操作Pool.apply_async(要调用的目标，(传递给目标的参数元组，))

        # 每次循环将会用空闲出来的子进程去调用目标

        po.apply_async(worker, (i, ))

        # 阻塞式操作

        # po.apply(worker, (i, ))

    print("start".center(24, "-"))

    po.close()

    po.join()

    print("end".center(24, "-"))