Python并发之多进程

from multiprocessing import Process

def foo(name):
    print('hello,%s'%name)

if __name__ == '__main__':
    p1=Process(target=foo,args=('world',))
    p2 = Process(target=foo, args=('China',))
    p1.start()
    p2.start()
    print('=====主进程=====')
    
    # == == =主进程 == == =
    # hello, world
    # hello, China
    #主进程和子进程并发执行  

from multiprocessing import Process

class MyProcess(Process):
    def __init__(self,name):
        super().__init__()
        self.name = name
    def run(self):
        print('hello,%s'%self.name)

if __name__ == '__main__':
    myprocess1 = MyProcess('world')
    myprocess2 = MyProcess('world')
    myprocess1.start()
    myprocess2.start()

实例方法:
p.start()：启动进程，并调用该子进程中的p.run() 

p.run():进程启动时运行的方法，正是它去调用target指定的函数，我们自定义类的类中一定要实现该方法  

p.terminate():强制终止进程p，不会进行任何清理操作，如果p创建了子进程，该子进程就成了僵尸进程，使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放，进而导致死锁

p.is_alive():如果p仍然运行，返回True

p.join([timeout]):主线程等待p终止。timeout是可选的超时时间

p.daemon：默认值为False，如果设为True，代表p为后台运行的守护进程，当p的父进程终止时，p也随之终止，并且设定为True后，p不能创建自己的新进程，必须在p.start()之前设置

p.name:进程的名称

p.pid：进程的pid

p.exitcode:进程在运行时为None、如果为–N，表示被信号N结束(了解即可) 

from multiprocessing import Process
import time
class MyProcess(Process):
    def __init__(self,name):
        super().__init__()
        self.name = name
    def run(self):
        time.sleep(3)
        print('hello,%s'%self.name)

if __name__ == '__main__':
    myprocess1=MyProcess('world')
    myprocess1.daemon = True
    myprocess1.start()
    print('结束')

#不会输出‘hello world’，因为设置为守护进程，主进程不会等待

from multiprocessing import Process,Lock
import time
def a_print(l): #需要传入对象，因为信息不共享
    l.acquire()
    print('我要打印信息')
    time.sleep(1)
    print('我打印完了')
    l.release()

if __name__ == '__main__':
    l = Lock()
    for i in range(20):
        p = Process(target=a_print,args=(l,))
        p.start()

from multiprocessing import Process,Queue,Semaphore
import time,random

def seat(s,n):
    s.acquire()
    print('学生%d坐下了'%n)
    time.sleep(random.randint(1,2))
    s.release()

if __name__ == '__main__':
    s = Semaphore(5)
    for i in range(20):
        p = Process(target=seat,args=(s,i))
        p.start()

    print('-----主进程-------')

from multiprocessing import Process,Queue
import time
def func1(queue):
    while True:
        info=queue.get()
        if info == None:
            return 
        print(info)

def func2(queue):
    for i in range(10):
        time.sleep(1)
        queue.put('is %d'%i)
    queue.put(None) #结束的标志
if __name__ == '__main__':
    q = Queue()
    p1 = Process(target=func1,args=(q,))
    p2 = Process(target=func2, args=(q,))

    p1.start()
    p2.start()

from multiprocessing import Pool
import time, random, os
def func(n):
    pid = os.getpid()
    print('进程%s正在处理第%d个任务'%(pid,n),'时间%s'%time.strftime('%H-%M-%S'))
    time.sleep(2)
    res = '处理%s'%random.choice(['成功','失败'])
    return res

if __name__ == '__main__':
    p = Pool(4) #创建4个进程，
    li = []
    for i in range(10):
        res = p.apply(func,args=(i,)) 交给进程池处理，处理完成才返回值，会阻塞，即使池内还有空余进程，相当于顺序执行
        li.append(res)

   
    for i in li:
        print(i)

#进程1916正在处理第0个任务 时间21-02-53
#进程1240正在处理第1个任务 时间21-02-55
#进程3484正在处理第2个任务 时间21-02-57
#进程7512正在处理第3个任务 时间21-02-59
#进程1916正在处理第4个任务 时间21-03-01
#进程1240正在处理第5个任务 时间21-03-03
#进程3484正在处理第6个任务 时间21-03-05
#进程7512正在处理第7个任务 时间21-03-07
#进程1916正在处理第8个任务 时间21-03-09
#进程1240正在处理第9个任务 时间21-03-11

from multiprocessing import Pool
import time, random, os
def func(n):
    pid = os.getpid()
    print('进程%s正在处理第%d个任务'%(pid,n),'时间%s'%time.strftime('%H-%M-%S'))
    time.sleep(2)
    res = '处理%s'%random.choice(['成功','失败'])
    return res

if __name__ == '__main__':
    p = Pool(4)
    li = []
    for i in range(10):
        res = p.apply_async(func,args=(i,)) 结果不会立刻返回，遇到阻塞，开启下一个进程，在这，相当于几乎同时出现四个打印结果（一个线程处理一个任务，处理完下个任务才能进来）
        li.append(res)

    p.close() #join之前需要关闭进程池
    p.join()  #因为异步，所以需要等待池内进程工作结束再继续
    for i in li:
        print(i.get()) #i是一个对象，通过get方法获取返回值，而同步则没有该方法