复习

1.同步、异步、阻塞、非阻塞    同步：所谓同步就是一个任务的完成需要依赖另外一个任务时，只有等待被依赖的任务完成后，依赖的任务才能算完成，这是一种可靠的任务序列    异步：所谓异步是不需要等待被依赖的任务完成，只是通知被依赖的任务要完成什么工作，依赖的任务也立即执行，只要自己完成了整个任务就算完成了。至于被依赖的任务最终是否真正完成，依赖它的任务无法确定，所以它是不可靠的任务序列。    阻塞：等待者除了等待消息通知之外不能做其它的事情，那么该机制就是阻塞的，表现在程序中,也就是该程序一直阻塞在该函数调用处不能继续往下执行。    非阻塞：因为他(等待者)没有阻塞在这个消息通知上，而是一边做自己的事情一边等待。

学习内容

1.进程的生命周期    1.代码执行结束，进程结束    2.主进程结束而子进程未结束，则主进程等待子进程结束再结束    3.子进程的存在不一定依赖父进程

代码区

1.起多进程

from multiprocessing import Process
import os

def func(args):
    print(args)
    print(‘子进程： %s‘%os.getpid())
    print(‘子进程的父进程： %s‘ % os.getppid())
    print(123)

if __name__ == ‘__main__‘:
    p = Process(target=func, args=(‘sd‘,))  # 注册
    #  p是一个进程对象，未启动
    p.start()  # 开启子进程
    print(‘父进程： %s‘ % os.getpid())
    print(‘父进程的父进程： %s‘ % os.getppid())
    print(‘*‘*10)

2.多进程的join方法

from multiprocessing import Process
import time

def func(arg1,arg2):
    print(‘*‘*arg1)
    time.sleep(5)
    print(‘*‘*arg2)

if __name__ == ‘__main__‘:
    p = Process(target=func, args=(10, 20))
    p.start()
    p.join()  # 感知一个子进程的结束，将异步改为同步
    print(‘=====：运行完了‘)

3.多进程合并

from multiprocessing import Process
import time

def func(arg1,arg2):
    print(‘*‘*arg1)
    time.sleep(5)
    print(‘*‘*arg2)

if __name__ == ‘__main__‘:
    p_lst = []
    for i in range(10):
        p1 = Process(target=func, args=(10*i, 20*i))
        p_lst.append(p1)
        p1.start()
    [p1.join() for p1 in p_lst]
    print(‘yuncing‘)

4.面向对象调多进程

from multiprocessing import Process
import os

class MyProcess(Process):
    def __init__(self,arg1):
        super().__init__()
        self.arg1 = arg1
    def run(self):
        print(self.name)
        print(self.pid)
        print(self.arg1, ‘参数‘)
        print(os.getpid())

if __name__ == ‘__main__‘:
    print(‘主进程：‘, os.getpid())
    p1 = MyProcess(1)
    p1.start()
    p2 = MyProcess(1)
    p2.start()

5.进程间数据隔离

from multiprocessing import Process
import os

def func():
    global n
    n = 0
    print(‘pid: %s‘%os.getpid(), n)

if __name__ == ‘__main__‘:
    n = 100
    p = Process(target=func)
    p.start()
    p.join()
    print(os.getpid(),n)

6.守护进程——随着主程序的代码执行完毕而结束

from multiprocessing import Process
import time

def func():
    while 1:
        time.sleep(1)
        print(‘copy that‘)

# def func():
#     print()

if __name__ == ‘__main__‘:
    p = Process(target=func)
    # p.daemon = True
    p.start()
    i = 0
    while i < 3:
        print(‘i am socketserver‘)
        time.sleep(5)
        i += 1
        print(i)

7.买车票——程序锁

from multiprocessing import Process
import json
import time
from multiprocessing import Lock

def show(i):
    with open(‘ticket‘) as f:
        dic = json.load(f)
    print(‘余票:%s‘%dic[‘ticket‘])

def buy_ticket(i,lock):
    lock.acquire()
    with open(‘ticket‘) as f:
        dic = json.load(f)
        time.sleep(0.1)
    if dic[‘ticket‘] > 0:
        dic[‘ticket‘] -= 1
        print(‘\033[32m %s OK！！！\033[0m‘%i)
    else:
        print(‘\033[31m %s NO！！！\033[0m‘%i)
    time.sleep(0.1)
    with open(‘ticket‘,‘w‘) as f:
        json.dump(dic,f)
    lock.release()

if __name__ == ‘__main__‘:
    for i in range(10):
        p = Process(target=show,args=(i,))
        p.start()
    lock = Lock()
    for i in range(10):
        p = Process(target=buy_ticket,args=(i,lock))
        p.start()

原文地址：https://www.cnblogs.com/wan2-0/p/10876825.html