Python进程梳理

1 multiprocessing lesson

"""
进程和线共用一个API，大体都是一样的
进程实现了并行，线程实现了并发
只是子进程开一个会占用多一倍内存，所以不能过多，而线程无要求
"""
"""
一，调用库不同，两种实例化方式相同（这是必然的）
"""
#线程
import threading
q=threading.Thread(target=fuuc,args=())
from threading import Thread
q= Thread(target=fuuc,args=())
#进程
import multiprocessing
q=multiprocessing.Process(target=fuuc,args=())
from multiprocessing import Process
q= Process(target=fuuc,args=())
"""继承实例化就不列举了
"""
"""
二.守护进（线）程名称和调用方式的不同
"""
#线程
q.setDaemon(True)  #在线程中是方法，Ture是参数
#进程
q.daemon=True       #在进程中是属性，Ture是属性值
"""
三，用的队列实例化方法不一样
"""
#线程
import queue
q=queue.Queue()
#进程
import multiprocessing
q=multiprocessing.Queue()
"""
四，创建同步/互斥锁的方式不同
"""
#线程
import threading
lock=threading.Lock()
#进程
import multiprocessing
lock=multiprocessing.Lock()

2 进程队列实现进程间通信

import multiprocessing


print("hhhhh")    #被主进程和子进程都执行了？
def foo(q):
    q.put(76)
    print(99999999999999999)
    print("son",id(q))
    q.put(67)
if __name__ == '__main__':
    q = multiprocessing.Queue()
    print("hahaha")
    p=multiprocessing.Process(target=foo,args=(q,))
    p.start()
    print("main",id(q))
    print("main",q.get())
    print(q.get())

3 进程间管道通信

from multiprocessing import Process, Pipe


def foo(conn):
    conn.send("你好，我是子进程")
    print(conn.recv())
    conn.close()  # 主动关闭通信管道


if __name__ == '__main__':
    father_pipe, son_pipe = Pipe()
    son = Process(target=foo, args=(son_pipe,))
    son.start()
    print(father_pipe.recv())
    father_pipe.send("你好，我是父进程")
    father_pipe.send("你好，我是父进程")  # 因为子进程已经主动关闭管道，所以发不过去，但也不会报错

4 managers实现进程间数据共享

#字典中重复添加不报错
from multiprocessing import Process,Manager
"""
type:list,dict,namespace,Lock,Rlock.....
"""

5 进程同步锁

from multiprocessing import Process,Lock
def foo(l,k):
    with l:  #上下文协议，不必自己上锁和解锁                 # l.acquire()
        print("Heelo", k)                                    # print("Heelo",k)
                                                             # l.release()
if __name__ == '__main__':
    lock=Lock()
    for i in range(1,11):
        Process(target=foo,args=(lock,i)).start()

"""
不这么做的话，子进程会抢占屏幕资源，在一个进程还没有打印结束的时候
另一个子进程也开始打印，造成打印错乱
"""

6 进程池

from multiprocessing import Pool   #可以直接用进程池创建子进程
import time,os
def Foo(i):
    time.sleep(1)
    print("son",os.getpid())
    print("son",i)
    return "这是回调函数的必要参数"
def Bar(args):
    print("Bar",os.getpid())
    print(args)
if __name__ == '__main__':
    pool=Pool(5)    #创建一个进程池对象，5代表同时只能有5个进程在执行
    for i in range(10):
        pool.apply_async(func=Foo,args=(i,),callback=Bar)  #回调函数callback是可选的，args要看前面的函数有没有要传参数
        print("main", os.getpid())
    pool.close()     #暂记固定格式
    pool.join()

    print("end...")
"""
回调函数是在主进程中执行的，可以用进程号来验证
回调函数式可选可不选的的，不是和进程池绑在一起的
回调函数的意义是在func函数执行完毕之后有一个返回值给回调函数参数，然后执行
可能在logging功能里会用到
"""