- 定义： 一个程序的运行起来后，代码+用到的资源称之为进程，他是操作系统分配资源的单位
多任务可以通过进程实现 - 进程的状态
工作中因为任务数往往大于cpu核数，即有一些任务正在运行而另一些任务在等待运行，因此有了不同的状态
- 就绪状态： 运行条件已经满足，正在等待cpu执行
-
执行状态： cpu正在执行
3.等待状态： 等待某些条件满足，例如IO操作
进程状态转化.png
线程和进程对比
功能
- 进程 ：能够完成多任务，例如：同一个电脑登录多个软件
- 线程 ： 能够完成多任务，例如，qq同时打开多个窗口
定义不同
- 进程： 系统资源分配和调度的单位
- 线程： 线程是进程的一个实体，是cpu调度和分派的基本单位，线程自己基本上不会拥有系统资源，只拥有一部分必不可少的资源（程序计数器,一组寄存器和栈），与同一组线程共享资源
区别
- 一个程序至少有一个进程，一个进程至少有一个线程
- 线程小于进程（资源占用），线程的并发性更高
- 线程不能独立运行必须依赖进程
优缺点：
线程执行开销小，但不利于资源管理和保护，进程正好相反
举例：
- 用法1
from multiprocessing import Process #导入进程模块
from time import sleep
def work1():
for i in range(6):
print(F'{i}正在浇花')
sleep(0.5)
def work2():
for i in range(6):
print(F'{i}正在打水')
sleep(0.5)
if __name__ == '__main__':
p1 = Process(target=work1) #创建进程任务
p2 = Process(target=work2)
p1.start() #启动进程任务
p2.start() #启动进程任务
p1.join() #等待子进程运行完成
p2.join()
print('___________结束————————————————————————')
- 用法2
from multiprocessing import Process
import time
class MyProcess(Process):
def run(self): #执行的方法
with open('test.txt',mode='a',encoding='utf-8') as f:
for i in range(2):
f.write('python')
time.sleep(0.5)
class MyProcess2(Process):
def run(self): #执行的方法
with open('test.txt',mode='a',encoding='utf-8') as f:
for i in range(2):
f.write('java {}')
time.sleep(0.5)
if __name__ == '__main__':
c1 = MyProcess(name='111')
c2 = MyProcess2()
c1.start()
print(c1.name)
c2.start()
multiprocessing
- Process 模块
grou ： 指定进程组一般用不到
target ： 指定任务，用zi进程执行这里的代码
name ： 给进程指定name
args : 指定任务函数传递的参数，以元组的形式
kwargs ： 给指定的函数传入命名参数
- Process 常用实例对象
- start() : 启动子进程
- is_alive : 判断子进程是否活着
- join(timeout) : 等待子进程执行技术,timeout等待时间
- terminate(): 不管任务是否完成，立即终止程序
- Process 常用属性
- name : 当前进程的别名 ，默认从Process-N ，N从1开始递增
- pid :当前进程的PID
from multiprocessing import Process, Lock
import time, os
class MyProcess(Process):
def __init__(self, meto):
super().__init__()
self.meto = meto
def run(self): # 执行的方法
meto.acquire() # 上锁
with open('test.txt', mode='a', encoding='utf-8') as f:
for i in range(5):
# 获取进程id的两种方式一种self.pid 一种os.pid
print('进程{}正在写入'.format(os.getpid()))
print('进程{}正在写入'.format(self.pid))
f.write('python/t')
time.sleep(1)
meto.release() # 解锁
class MyProcess2(Process):
def __init__(self, meto):
super().__init__()
self.meto = meto
def run(self): # 执行的方法
meto.acquire() # 上锁
with open('test.txt', mode='a', encoding='utf-8') as f:
for i in range(5):
print('进程{}正在写入'.format(self.pid)) # 获取进程id的两种方式一种self.pid 一种os.pid
f.write('java\n')
time.sleep(1)
meto.release() # 解锁
meto = Lock() #多进程公用外部资源需要加锁
def main():
c1 = MyProcess(meto)
c2 = MyProcess2(meto)
c1.start()
c2.start()
c1.join()
c2.join()
# c1.terminate() # 不管是否执行完成直接停止
if __name__ == '__main__':
main()
进程间的通讯
- 进程间是无法使用呢全局变量的，每个进程会将全局变量单独拷贝一份使用，进程间需要使用通讯
错误举例
#queue只能在同一个进程中各个线程之间的通讯
"""
1,进程间的通讯
"""
#用法1
from multiprocessing import Process,Lock #导入进程模块
from queue import Queue
import os
qc = Queue()
for i in range(5):
qc.put(i)
def work3():
for i in range(5):
print('进程{}获取值{}'.format(os.getpid(),qc.get()))
def work4():
for i in range(5):
print('进程{}获取值{}'.format(os.getpid(), qc.get()))
meto = Lock()
#用法1
if __name__ == '__main__':
p1 = Process(target=work3) #创建进程任务
p2 = Process(target=work4)
p1.start() #启动进程任务
p2.start() #启动进程任务
p1.join() #等待子进程运行完成
p2.join()
print('___________结束————————————————————————')
输出值
两个进程各自获取一份数据
错误.png
正确的举例
# 进程模块中的queue,可用于多个进程之间的通讯
"""
1,进程间的通讯
"""
#用法1
from multiprocessing import Process,Lock,Queue #导入进程模块
# from queue import Queue
import os,time
qc = Queue()
for i in range(5):
qc.put(i)
def work3(qc):
while not qc.empty(): #判断队列中的参数是否为空
print('进程{}获取值{}'.format(os.getpid(),qc.get()))
time.sleep(1)
def work4(qc):
while not qc.empty():
print('进程{}获取值{}'.format(os.getpid(), qc.get()))
meto = Lock()
#用法1
if __name__ == '__main__':
p1 = Process(target=work3,args=(qc,)) #创建进程任务并将进程间传递的参数传入
p2 = Process(target=work4,args=(qc,)) #创建进程任务并将进程间传递的参数传入
p1.start() #启动进程任务
p2.start() #启动进程任务
p1.join() #等待子进程运行完成
p2.join()
print('___________结束————————————————————————')
结果
多个进程公用一份数据
正确.png
网友评论