1.进程介绍
2.进程创建
3.进程间的通信
4.进程池
# 进程介绍:一个程序运行起来后,代码+用到的资源称之为进程
# 1.进程状态:
# 就绪态:正在等CPU执行
# 执行态:CPU正在执行其功能
# 等待态:等待某些条件满足
# import time
# print('程序开始') # 运行状态
# name = input('请输入你的名字:') # 用户输入,进入阻塞
# print(name) # 运行状态
# time.sleep(1) # 睡眠, 阻塞状态
# print('程序结束') # 运行状态
# 2.进程语法结构
# multiprocessing 模块 Process类
# Process()参数:
# target:表示调用对象,子进程要执行的任务
# args: 传递参数,以元组的形式传递
# kwargs: 以字典的形式传递参数
# name: 子进程名称
# Process()常用方法:
# start():启动子进程
# is_alive():判断子进程是否还活着,存活返回True, 否则False
# join(): 主进程等待子进程终止
# Process()常用属性:
# name:当前进程的别名
# pid: 当前进程的进程号
# 3.属性举例
# from multiprocessing import Process
# import os
# os.getpid() : 获取当前进程的进程号
# os.getppid(): 获取父进程的进程号
# def one():
# print('one子进程id:%s, 父进程id:%s' % (os.getpid(), os.getppid()))
#
# def two():
# print('two子进程id:%s, 父进程id:%s' % (os.getpid(), os.getppid()))
#
# if __name__ == '__main__':
# 创建子进程
# p1 = Process(target=one)
# p2 = Process(target=two)
# 开启子进程
# p1.start()
# p2.start()
# print('one中的pid:', p1.pid)
# p1.name = '九歌'
# print('p1的进程名是:', p1.name)
# print('主进程:%s, 父进程:%s' % (os.getpid(), os.getppid()))
# 4.# is_alive():判断子进程是否还活着,存活返回True, 否则False
# # join(): 主进程等待子进程终止
# from multiprocessing import Process
#
# # def one():
# # print(123)
# #
# # def two():
# # print(456)
# #
# # if __name__ == '__main__':
# # # 创建子进程
# # p1 = Process(target=one)
# # p2 = Process(target=two)
# # # 开启子进程
# # p1.start()
# # p2.start()
# # p1.join() # 主线程等待p1终止, 主进程处于等待的状态,p1处于运行的状态
# # p2.join()
#
#
# # print('这是主进程')
# # print('p1的状态是:', p1.is_alive())
# # print('p2的状态是:', p2.is_alive())
# # 5. 进程不会共享全局变量
# import time
#
# li = []
# # 写入:
# def funa():
# for i in range(3):
# li.append(i)
# # time.sleep(1)
# print('这是funa中的:', li)
#
# # 读取:
# def funb():
# print('这是funb中的:', li)
#
#
# if __name__ == '__main__':
# p1 = Process(target=funa)
# p2 = Process(target=funb)
# p1.start()
# p1.join() # 阻塞主进程
# p2.start()
#
# 1. Queue 队列 先进先出
# 入队:将一个数据放到队列尾部 q.put() 放入数据
# 出队:从队列的头部取出一个元素 q.get() 取出数据
# from queue import Queue
# q = Queue() # 初始化一个Queue对象
# q.put(123) # 放入数据
# q.put('b')
# q.put([1, 2, 3])
# q.put('a')
# Queue.full() 如果队列满了,返回为True, 否则为False
# print(q.full())
# print(q.get()) # 取出数据
# print(q.get())
# print(q.get())
# Queue.empty() 如果队列为空,返回为True, 否认为False
# print(q.empty())
# print('现在的消息数量:', q.qsize())
# 2. 进程操作队列
#
# from multiprocessing import Process, Queue
# import time
# import random
#
# li = ['a', 'b', 'c', 'd']
#
#
# # 写数据
# def write(w1): # 放入数据, w1实际就是q,也就是初始化的Queue对象
# for i in li:
# print('将%s放进队列中' % i)
# w1.put(i)
# time.sleep(random.random())
#
#
# # 读数据
# def read(r1): # 取出数据
# while True:
# if not r1.empty():
# val = r1.get()
# print('从队列中获取:', val)
# time.sleep(random.random())
# else:
# break
#
#
# if __name__ == '__main__':
# # 初始化一个Queue对象
# q = Queue() # 忽略此参数,没有大小限制
# p1 = Process(target=write, args=(q, ))
# p2 = Process(target=read, args=(q, ))
# # 启动子进程p1, 先放入数据
# p1.start()
# # 等待p1放完
# p1.join()
# # 启动子进程p2,取出数据
# p2.start()
# # print('p2的is_alive', p2.is_alive())
from multiprocessing import Process, Queue
import time
import random
li = ['a', 'b', 'c', 'd']
def write(w):
for i in li:
print('将%s放入队列中' % i)
w.put(i)
time.sleep(random.random())
def read(r):
while True:
if not r.empty():
print('从队列读到的数据为:', r.get())
time.sleep(random.random())
else:
break
if __name__ == '__main__':
q = Queue()
p1 = Process(target=write, args=(q, ))
p2 = Process(target=read, args=(q, ))
p1.start()
p1.join()
p2.start()
print(p1.is_alive())
print(p2.is_alive())
# # 1.进程池:定义一个池子,里面放上固定数量的进程。
# # 主要方法:
# # apply_async: 非阻塞
# # apply:阻塞
# # close():关闭进程池
# # join(): 主进程阻塞(只能在close之后调用)
#
#
# from multiprocessing import Pool
# import time
#
# def work(n):
# print('我们在上课')
# time.sleep(0.5)
# return n ** 2
#
# # 2.异步
# # apply_async:异步非阻塞, 不用等待当前进程执行完毕,
# 随时根据系统调度来进行进程切换
# # apply_async(任务名, 参数)
#
#
# # if __name__ == '__main__':
# # # 创建进程池
# # p = Pool(3)
# # li = []
# # for i in range(6): # i的值:0-5
# # res = p.apply_async(work, args=(i, )) # 根据进程池中有的进程数,每次最多有3个子进程在异步运行
# # li.append(res)
# #
# #
# # p.close() # 关闭进程池
# # p.join() # 等待所有子进程执行完
# #
# # # 使用get方法来获取apply_async的结果
# # for j in li:
# # print(j.get())
#
# # 3.同步
# # apply:同步阻塞,等待当前子进程执行完,再执行下一个进程
# # if __name__ == '__main__':
# # # 创建进程池
# # p = Pool(3)
# # li = []
# # for i in range(6):
# # res = p.apply(work, (i, ))
# # li.append(res)
# #
# # print(li)
#
# # 4.进程池通信
# from multiprocessing import Pool, Manager
# import os
#
# # 写数据
# def write(q1):
# print('write的进程号:%s, 父进程:%s' % (os.getpid(), os.getppid()))
# for i in 'six':
# print('write中的:', i)
# q1.put(i) # 放入数据
#
# # 读数据
# def read(q2):
# print('read的进程号:%s, 父进程:%s' % (os.getpid(), os.getppid()))
# for i in range(q2.qsize()): # q.qsize() 返回队列中数据的数量
# print('取出数据:', q2.get())
#
#
# if __name__ == '__main__':
# # print('开始的:', os.getpid())
# # 实例化一个队列对象
#
# q = Manager().Queue()
# p = Pool() # 创建进程池
# p.apply_async(write, (q, ))
# p.apply_async(read, (q, ))
#
# p.close()
# p.join()
#
from multiprocessing import Pool, Manager
import os
def write(q1):
print('write of id: %s, father id: %s' % (os.getpid(), os.getppid()))
for i in 'six':
print('write: ', i)
q1.put(i)
def read(q2):
print('read id: %s, father id: %s' % (os.getpid(), os.getppid()))
for i in range(q2.qsize()):
print('read data:', q2.get())
if __name__ == '__main__': # 加主程序入口后,若此文件被其他文件导入,这下面的代码不会被执行
print('process id: ', os.getpid())
q = Manager().Queue()
p = Pool()
p.apply(write, (q,))
p.apply(read, (q, ))
p.close()
p.join()