进程间通信方式

multiprocessing.Queue

Queue 实现进程间通信的方式，就是使用了操作系统给开辟的一个队列空间，各个进程可以把数据放到该队列中，当然也可以从队列中把自己需要的信息取走

import multiprocessing
def processFun(queue,name):
    print(multiprocessing.current_process().pid,"进程放数据：",name)
    #将 name 放入队列
    queue.put(name)
if __name__ == '__main__':
    # 创建进程通信的Queue
    queue = multiprocessing.Queue()
    # 创建子进程
    process = multiprocessing.Process(target=processFun, args=(queue,"http://c.biancheng.net/python/"))
    # 启动子进程
    process.start()
    #该子进程必须先执行完毕
    process.join()
    print(multiprocessing.current_process().pid,"取数据：")
    print(queue.get())


执行结果：
27100 进程放数据： http://c.biancheng.net/python/
24188 取数据：
http://c.biancheng.net/python/

multiprocessing.Pipe

Pipe 直译过来的意思是“管”或“管道”，该种实现多进程编程的方式，和实际生活中的管（管道）是非常类似的。通常情况下，管道有 2 个口，而 Pipe 也常用来实现 2 个进程之间的通信，这 2 个进程分别位于管道的两端，一端用来发送数据，另一端用来接收数据

conn1, conn2 = multiprocessing.Pipe( [duplex=True] )

duplex=True 默认值，说明管道是双向的，进程既可以写数据又可以读数据，duplex=False，说明管道是单向的，conn1 只能用来接收数据，而 conn2 只能用来发送数据

import multiprocessing
def processFun(conn,name):
    print(multiprocessing.current_process().pid,"进程发送数据：",name)
    conn.send(name)
if __name__ == '__main__':
    #创建管道
    conn1,conn2 = multiprocessing.Pipe()
    # 创建子进程
    process = multiprocessing.Process(target=processFun, args=(conn1,"http://c.biancheng.net/python/"))
    # 启动子进程
    process.start()
    process.join()
    print(multiprocessing.current_process().pid,"接收数据：")
    print(conn2.recv())


执行结果：
28904 进程发送数据： http://c.biancheng.net/python/
28880 接收数据：
http://c.biancheng.net/python/

multiprocessing.Manager

from multiprocessing import Process, Manager
 
def f( shareDict, shareList ):
    shareDict[1] = '1'
    shareDict['2'] = 2
    shareDict[0.25] = None
    shareList.reverse() # 翻转列表
 
if __name__ == '__main__':
    manager = Manager()
    shareDict = manager.dict() # 创建共享的字典类型
    shareList = manager.list( range( 10 ) ) # 创建共享的列表类型
    p = Process( target = f, args = ( shareDict, shareList ) )
    p.start()
    p.join()
    print shareDict
    print shareList

子进程退出：

# -*- coding:utf-8 -*-
import multiprocessing
import os
import sys
import time
from multiprocessing import pool
 
from cheetah.utils.logger import logger
 
mgr = multiprocessing.Manager()
 
pid = os.getpid()
 
pool = multiprocessing.Pool(10)
 
 
def module_test(name):
    try:
        logger.info(u'节点 %s 正在编译 进程名 %s 进程id %s' %
                    (name, multiprocessing.current_process().name, os.getpid()))
 
        if name == 3:
            logger.info(u'执行退出操作')
            # pool.terminate() # 运行报错
            # os.killpg(os.getpgid(pid), 9) # 结束整个进程组 即杀死了pycharm进程
 
        else:
            time.sleep(10)
        logger.info("----name---%s" % name)
    except Exception:
        logger.info("----name---%s" % name)
 
 
array = [0, 0, 1, 1, 2, 2, 3, 4, 6, 6, 7, 8]
array1 = [0, 1, 2, 3, 4, 5]
 
if __name__ == '__main__':
 
    for m in array1:
        pool.apply_async(func=module_test, kwds={"name": m})
    pool.close()
    pool.join()
    print ('111')

一、https://blog.csdn.net/weixin_34580002/article/details/113966210

根据此资料，使用 os.killpg(os.getpgid(stf_p.pid), 9) 杀死一个进程组

二、https://blog.csdn.net/weixin_43899202/article/details/120597581

遍历获取子进程 id，逐个杀死

三、调用线程池的 pool.terminate() 结束线程池