一：隐藏了丑陋的硬件调用接口，为应用程序员提供调用硬件资源的更好，更简单，更清晰的模型（系统调用接口）。应用程序员有了这些接口后，就不用再考虑操作硬件的细节，专心开发自己的应用程序即可。
例如：操作系统提供了文件这个抽象概念，对文件的操作就是对磁盘的操作，有了文件我们无需再去考虑关于磁盘的读写控制（比如控制磁盘转动，移动磁头读写数据等细节），
二：将应用程序对硬件资源的竞态请求变得有序化
例如：很多应用软件其实是共享一套计算机硬件，比方说有可能有三个应用程序同时需要申请打印机来输出内容，那么a程序竞争到了打印机资源就打印，然后可能是b竞争到打印机资源，也可能是c，这就导致了无序，打印机可能打印一段a的内容然后又去打印c...,操作系统的一个功能就是将这种无序变得有序。
from multiprocessing import Process #多进程必用模块
def func():
print(12345)
if __name__ == ‘__main__‘:
p = Process(target=func) # 把一个函数注册进这个进程里面
# p是一个进程对象，还没有启动进程
p.start() #进程启动
print(‘*‘*10)
#多进程：带参数的函数
from multiprocessing import Process
def func(args):
print(args)
if __name__ == ‘__main__‘:
p = Process(target=func,args=(‘参数‘,)) #传参时必须是元组
p.start() #进程启动
import os
from multiprocessing import Process #多进程必用模块
def func():
print(12345)
print(‘子进程：‘,os.getpid())
print(‘子进程的父进程：‘,os.getppid())
if __name__ == ‘__main__‘:
p = Process(target=func) # 把一个函数注册进这个进程里面
# p是一个进程对象，还没有启动进程
p.start() #进程启动
print(‘*‘*10)
print(‘主进程：‘,os.getpid())
print(‘主进程的父进程：‘,os.getppid())
感知一个子程序的结束，将异步程序改为同步程序
import time
from multiprocessing import Process
def func(arg1,arg2):
print(‘*‘ * arg1)
time.sleep(5)
print(‘*‘ * arg2)
if __name__ == ‘__main__‘:
p = Process(target=func,args=(5,10))#传参时必须是元组
p.start() #进程启动
p.join() #是感知一个子程序的结束，将异步程序改为同步
print(‘=========:执行结束‘)
多个子进程执行完后，主程序再立即执行，需要用到join方法
from multiprocessing import Process
def func(arg1,arg2):
print(‘*‘*arg1)
print(‘=‘*arg2)
if __name__ == ‘__main__‘:
p_list = []
for i in range(10):
p = Process(target=func,args=(10*i,20*i))
p_list.append(p)
p.start()
[p.join() for p in p_list] #p.join()相当于把子程序都执行完了，再运行主程序
#子程序由异步变成同步
print(‘主程序执行完毕‘)
应用场景：写文件：同时开启500个进程写文件，异步执行，写文件执行完毕后打印目录
import os
from multiprocessing import Process
def func(filename,content):
with open(filename,‘w‘)as f:
f.write(content*10*‘*‘)
if __name__ == ‘__main__‘:
p_list = []
for i in range(1,5):
p = Process(target=func,args=(‘info%s‘%i,i))
p_list.append(p)
p.start()
[p.join() for p in p_list] #之前所有进程必须都执行完才能执行下面的代码
print([i for i in os.walk(r‘D:\pycharm_project\python36‘)])
启动多个子程序调用函数，同时执行
import time
from multiprocessing import Process
def func(arg1,arg2):
print(‘*‘*arg1)
time.sleep(5)
print(‘*‘*arg2)
if __name__ == ‘__main__‘: #启用多个子程序同时运行
p1 = Process(target=func,args=(3,10)) #传参
p1.start() #启动子进程
p2 = Process(target=func,args=(4,11))
p2.start()
p3 = Process(target=func,args=(5,12))
p3.start()
也可以使用for循环的方法
import time
from multiprocessing import Process
def func(arg1,arg2):
print(‘*‘*arg1)
time.sleep(5)
print(‘*‘*arg2)
if __name__ == ‘__main__‘:
for i in range(4): #使用for循环该进程，相当于开启了4个子进程
p1 = Process(target=func,args=(3,10))
p1.start()
自定义类，必须继承Process类
必须实现一个run方法，run方法中是在子进程中执行的代码
start方法自动处理run方法
import os
from multiprocessing import Process
class MyProcess(Process):
def run(self):
print(os.getpid()) #要执行的子进程方法
if __name__ == ‘__main__‘:
print(‘主：‘,os.getpid())
p1 = MyProcess() #实例化类
p1.start() #start方法自动处理run方法
p2 = MyProcess() #实例化类
p2.start() #启动第二个子进程
# 自定义类，必须继承Process类
# 必须实现一个run方法，run方法中是在子进程中执行的代码
传参的方式
import os
from multiprocessing import Process
class MyProcess(Process):
def __init__(self,arg1,arg2):
super().__init__()
self.arg1 = arg1
self.arg2 = arg2
def run(self):
print(self.pid)
print(self.name)
print(self.arg1)
print(self.arg2)
if __name__ == ‘__main__‘:
print(‘主：‘,os.getpid())
p1 = MyProcess(1,2) #实例化类
p1.start() #启动该子进程
p2 = MyProcess(3,4) #实例化类
p2.start() #启动第二个子进程
子进程中的数据无法修改主进程中的数据
import os
from multiprocessing import Process
def func():
global n #声明了一个全局变量
n = 0 #重新定义一个全局变量的n
print(‘子进程pid:%s‘%os.getpid(),n)
if __name__ == ‘__main__‘: #windows系统下必须使用main
n = 100
p = Process(target=func)
p.start()
p.join()
print(‘主进程pid:%s‘%os.getpid(),n)
#结果为：
子进程pid:432 0 #在子进程中声明了修改一个全局变量，但是主进程的变量并没有发生改变
主进程pid:6696 100
开启多个client端，实现多并发
待优化：多进程会增加服务器内存损耗
# server:
import socket
from multiprocessing import Process
def serve(conn):
ret = ‘你好‘.encode(‘utf-8‘)
conn.send(ret)
msg = conn.recv(1024).decode(‘utf-8‘)
print(msg)
conn.close()
if __name__ == ‘__main__‘:
sk = socket.socket()
sk.bind((‘127.0.0.1‘,8080))
sk.listen()
while True:
conn,addr = sk.accept()
p = Process(target=serve,args=(conn,))
p.start()
sk.close()
# client:
import socket
sk = socket.socket()
sk.connect((‘127.0.0.1‘,8080))
msg = sk.recv(1024).decode(‘utf-8‘)
print(msg)
msg2 = input(‘>>>‘).encode(‘utf-8‘)
sk.send(msg2)
sk.close()
守护进程会随着主进程的代码执行完毕而结束,而不是主进程结束
一定是在子进程start之前设置
import time
from multiprocessing import Process
def func():
while True:
time.sleep(0.2)
print(‘我还活着‘)
def func2():
print(‘in func2 start‘)
time.sleep(8)
print(‘in func2 finished‘)
if __name__ == ‘__main__‘:
p = Process(target=func)
p.daemon = True #设置该子进程为守护进程
p.start()
p2 = Process(target=func2)
p2.start()
i = 0
while i < 5:
print(‘我是socket server‘)
time.sleep(1)
i+=1
# func随着主进程的代码执行结束而结束，而func2子进程继续执行，执行完毕后，主进程整体结束并关闭
在主进程内结束一个子进程p.terminate()
import time
from multiprocessing import Process
def func():
while True:
time.sleep(0.2)
print(‘我还活着‘)
def func2():
print(‘in func2 start‘)
time.sleep(5)
print(‘in func2 finished‘)
if __name__ == ‘__main__‘:
p = Process(target=func)
p.daemon = True #设置该子进程为守护进程
p.start()
p2 = Process(target=func2)
p2.start()
p2.terminate() #结束一个子进程
print(p2.is_alive()) #立即检验子进程存活状态，此时子进程活着，因为执行后需要操作系统响应的过程
time.sleep(1)
print(p2.is_alive()) #检验一个进程是否还活着（True/Flase）
print(p.name) #输出子进程的名字
必须保证数据安全，所以异步变为同步执行修改数据的代码
进程锁应用：显示余票和买票
#ticket文件代码：
{"ticket": 1}
#主程序代码：
import json
import time
from multiprocessing import Process
from multiprocessing import Lock #启用进程锁
def show(i):
with open(‘ticket‘)as f:
dic = json.load(f)
time.sleep(0.1) #模拟拿数据时的网络延迟
print(‘余票：%s‘%dic[‘ticket‘])
def buy_ticket(i,lock):
lock.acquire() #拿钥匙进门，只能拿钥匙的进程进去，其他进程为阻塞状态，直到还钥匙为止
with open(‘ticket‘)as f:
dic = json.load(f)
time.sleep(0.2)
if dic[‘ticket‘] > 0:
dic[‘ticket‘] -= 1
print(‘\033[32m%s买到票了\033[0m‘%i)
else:
print(‘\033[31m%s没票了\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/lynlearnde/p/13471723.html