python多进程

进程：正在进行的一个过程或者说一个任务

程序：仅仅只是一堆代码而已，而进程指的是程序的运行过程

僵尸进程：子进程结束后会被保留，等待父进程回收，期间是僵尸状态

守护进程：子进程设置为守护进程，一旦父进程结束，子进程也立马结束

守护进程设置方式：p.daemon = True

---

并发：进程间快速切换，看起来同时运行

并行：同时运行，需于多个cpu

---

开启子进程的两种方式

from multiprocessing import Process
-----------------------------------------------------------------------
#方式一
def task(name): 
    print('子进程%s正在运行' % name)


if __name__ == '__main__':  #必须要这个！
    p = Process(target=task, args=('1'), name='一')  # 真正的进程名为‘一’
    p.start()

-------------------------------------------------------------------------
# 方式二
class MyProcess(Process):
    def __init__(self, name):
        super().__init__()
        self.name = name

    def run(self):  # 不能加参数
        print('子进程%s正在运行' % self.name)
        
if __name__ == '__main__':
    p =MyProcess('1')
    p.start()   # 实际触发的是run方法

查看pid与ppid以及其他属性和方法

os.getpid(),os.getppid()：查看进程id和父进程id

current_process方法下的current_process().pid变量也是的

-------------------------------------------------------------------------------------

p.start()：进程开启

p.terminate()：结束进程

p.join()：阻塞父进程，等待子进程p运行完毕后，父进程才继续运行

p.is_alive()：判断进程是否活着

active_children方法返回活着的子进程的列表

---

互斥锁

from multiprocessing import Process, Lock, current_process


def task(mutex):
    mutex.acquire()
    print('lala', current_process().name)
    print('done')
    mutex.release()


if __name__ == '__main__':
    mutex = Lock()  # 在父进程中实例化互斥锁

    for i in range(3):
        p = Process(target=task, args=(mutex,))  # 传递给每个子进程
        p.start()

-------------------------------------------------------------
# 每个子进程内打印的顺序正确
lala
Process - 2
done
lala
Process - 1
done
lala
Process - 3
done

---

队列

from multiprocessing import Queue

q=Queue(3)  # 队列容量 3

q.put('hello')
q.put({'a':1})
q.put([3,3,3,])
print(q.full())     # 是否已满

print(q.get())
print(q.get())
print(q.get())
print(q.empty())    # 是否已空
--------------------------------
True
hello
{'a': 1}
[3, 3, 3]
True

生产者-消费者模型

生产者多个，消费者多个。生产进程生产完毕（把自己所有数据都扔进了队列中），父进程往队列中扔n(n=消费者数量)个结束信号（None)，消费者拿到结束信号则结束

from multiprocessing import Process,Queue
import time

def producer(q):
    for i in range(10):
        res='包子%s' %i
        time.sleep(0.5)
        print('生产者生产了%s' %res)

        q.put(res)

def consumer(q):
    while True:
        res=q.get()
        if res is None:break
        time.sleep(1)
        print('消费者吃了%s' % res)



if __name__ == '__main__':
    #容器
    q=Queue()

    #生产者们
    p1=Process(target=producer,args=(q,))
    p2=Process(target=producer,args=(q,))
    p3=Process(target=producer,args=(q,))

    #消费者们
    c1=Process(target=consumer,args=(q,))
    c2=Process(target=consumer,args=(q,))

    p1.start()
    p2.start()
    p3.start()
    c1.start()
    c2.start()

    p1.join()
    p2.join()
    p3.join()
    q.put(None)
    q.put(None)

JoinableQueue

要点：

消费进程每取出一个数据，发送task_done信号

父进程等待所有生产进程生产完毕，然后等待队列中数据清空（q.join())

from multiprocessing import Process,JoinableQueue
import time

def producer(q):
    for i in range(2):
        res='包子%s' %i
        time.sleep(0.5)
        print('生产者生产了%s' %res)

        q.put(res)
    # q.join()  可以放这里，但感觉效率不高

def consumer(q):
    while True:
        res=q.get()
        if res is None:break
        time.sleep(1)
        print('消费者吃了%s' % res)
        q.task_done()


if __name__ == '__main__':
    #容器
    q=JoinableQueue()

    #生产者们
    p1=Process(target=producer,args=(q,))
    p2=Process(target=producer,args=(q,))
    p3=Process(target=producer,args=(q,))

    #消费者们
    c1=Process(target=consumer,args=(q,))
    c2=Process(target=consumer,args=(q,))
    c1.daemon=True
    c2.daemon=True

    p1.start()
    p2.start()
    p3.start()
    c1.start()
    c2.start()

    p1.join()
    p2.join()
    p3.join()
    q.join()
    print('主')