活动地址：CSDN21天学习挑战赛
学习的最大理由是想摆脱平庸，早一天就多一份人生的精彩；迟一天就多一天平庸的困扰。各位小伙伴，如果您：
想系统/深入学习某技术知识点…
一个人摸索学习很难坚持，想组团高效学习…
想写博客但无从下手，急需写作干货注入能量…
热爱写作，愿意让自己成为更好的人…
目录
一、进程
程序就是一个个可执行的.exe文件，而进程就是程序运行的状态
程序只有一个，但是进程可以多个 程序是死的，而进程则是分配了资源
进程=代码+资源，进程是操作系统分配资源的基本单位
01.进程的创建
import multiprocessing
import time
def test1():
while True:
print("1------")
time.sleep(1)
def test2():
while True:
print("2------")
time.sleep(1)
def main():
# t1 = threading.Thread(target=test2)
# t2 = threading.Thread(target=test1)
# t1.start()
# t2.start()
p1 = multiprocessing.Process(target=test2)
p2 = multiprocessing.Process(target=test1)
p1.start() #
p2.start()
if __name__ == "__main__":
main()
# 虚拟机ps看进程 ps -aux看所有的进程
# 杀死进程：kill 进程号
# 线程方式实现多任务 每一个线程拥有和主线程一样的代码+资源
# 一样的东西不会复制，然后执行的时候代码是一样的所以代码是共享的
# 对于磁盘来说可以共享就共享不可以才修改
1>与线程的对比
从创建方式来说：对于多进程来说导入threading库而进程导入multiprocessing库，其次对于进程来说通过他t1= multiprocessing.Process(target=函数名)创建对象,t1.start()创建进程。
线程(程序里面实现多任务)：一个qq中的多个聊天窗口
进程(程序多开)：一台电脑上同时运行多个qq,进程的箭头先有才有线程的箭头
一个进程中至少有一个主线程
进程是一个资源分配的单位---资源的总和，线程拿资源去做
多线程的多任务指：一个进程里面有多个箭头(线程：调度)
多进程的多任务指:开辟了多个相同的资源空间，每个资源空间有一个线程
02.通过队列完成进程间通信
队列：先保存的数据先输出，后保存的数据后输出相当于检票先进先出，后进后出
栈：先进后出，相当于进电梯，先进的后出，后进的先出。
# 多任务间进程间的通信socket是进程间通信的一种
# Queue队列：先进的先出后进的后出(排队进火车站)-----进程间数据通信
# 栈：先进的后出(进电梯)
from multiprocessing import Queue
q = Queue(3) # 初始化一个Queue对象，最多可接收三条put消息
q.put("消息1") # 放数据
q.put("消息2")
print(q.full()) # False判断是否满了
q.put("消息3")
print(q.full()) # True
# 因为消息列队已满下面的try都会抛出异常，第一个try会等待2秒后再抛出异常，第二个Try会立刻抛出异常
try:
q.put("消息4", True, 2)
except:
print("消息列队已满，现有消息数量:%s" % q.qsize())
try:
q.put_nowait("消息4")
except:
print("消息列队已满，现有消息数量:%s" % q.qsize())
# 推荐的方式，先判断消息列队是否已满，再写入
if not q.full():
q.put_nowait("消息4")
# 读取消息时，先判断消息列队是否为空，再读取
if not q.empty():
for i in range(q.qsize()):
print(q.get_nowait())
# q.get() 取数据，先放的先取，但是如果里面已经没有了你还取，会一直等着（堵塞）
# q.get_nowait()会通过异常来告诉你已经没有了
# q.put() 加数据，如果已经满了在加会堵塞
# queue 1.连通两个进程 2.解耦：耦合性越高越不好
说明
初始化Queue()对象时（例如：q=Queue()），若括号中没有指定最大可接收的消息数量，或数量为负值，那么就代表可接受的消息数量没有上限（直到内存的尽头）；
Queue.qsize()：返回当前队列包含的消息数量；
Queue.empty()：如果队列为空，返回True，反之False ；
Queue.full()：如果队列满了，返回True,反之False；
Queue.get([block[, timeout]])：获取队列中的一条消息，然后将其从列队中移除，block默认值为True；
1）如果block使用默认值，且没有设置timeout（单位秒），消息列队如果为空，此时程序将被阻塞（停在读取状态），直到从消息列队读到消息为止，如果设置了timeout，则会等待timeout秒，若还没读取到任何消息，则抛出"Queue.Empty"异常；
2）如果block值为False，消息列队如果为空，则会立刻抛出"Queue.Empty"异常；
Queue.get_nowait()：相当Queue.get(False)；
Queue.put(item,[block[, timeout]])：将item消息写入队列，block默认值为True；
1）如果block使用默认值，且没有设置timeout（单位秒），消息列队如果已经没有空间可写入，此时程序将被阻塞（停在写入状态），直到从消息列队腾出空间为止，如果设置了timeout，则会等待timeout秒，若还没空间，则抛出"Queue.Full"异常；
2）如果block值为False，消息列队如果没有空间可写入，则会立刻抛出"Queue.Full"异常；
- Queue.put_nowait(item)：相当Queue.put(item, False)；
03.多进程通过队列实现数据共享
import multiprocessing
def down_from_web(q):
"""下载数据"""
# 模拟从网上下载的数据
data = [11, 22, 33, 44]
# 向队列中写入数据
for temp in data:
q.put(temp)
print("---下载器已经下载完毕数据并且存到队列中")
def analysis_data(q):
"""数据处理"""
waiting_analysis_data = list()
# 从队列中获取数据
while True:
data = q.get()
waiting_analysis_data.append(data)
# 模拟数据处理
if q.empty():
print(waiting_analysis_data)
break
def main():
# 创建一个队列
q = multiprocessing.Queue() # 里面不放则默认最大
p1 = multiprocessing.Process(target=down_from_web, args=(q,))
p2 = multiprocessing.Process(target=analysis_data, args=(q,))
p1.start()
p2.start()
if __name__ == "__main__":
main()
总结：
通过q = multiprocessing.Queue()创建队列
然后q.put()存数据到队列
q.get()取数据
04.进程池
介绍：
一个特殊的容器可以容纳很多进程
初始化Pool时，可以指定一个最大进程数，
当有新的请求提交到Pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；
但如果池中的进程数已经达到指定的最大值，那么该请求就会等待，
直到池中有进程结束，才会用之前的进程来执行新的任务。
进程的创建和销毁会消耗较多的资源
所以进程池的概念减少了这部分的消耗
总结：
初始化Pool时，可以指定一个最大进程数，当有新的请求提交到Pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到指定的最大值，那么该请求就会等待，直到池中有进程结束，才会用之前的进程来执行新的任务
demo:
import os
import random
import time
import multiprocessing
def worker(msg):
t_start = time.time()
print("%s开始执行,进程号为%d" % (msg, os.getpid()))
# random.random()随机生成0~1之间的浮点数
time.sleep(random.random()*2)
t_stop = time.time()
print(msg, "执行完毕，耗时%0.2f" % (t_stop-t_start))
def main():
po = multiprocessing.Pool(3) # 定义一个进程池，最大进程数3(不会立刻创建3个什么时候用什么时候创建)
for i in range(0, 10): # 添加10个任务
# Pool().apply_async(要调用的目标,(传递给目标的参数元祖,))
# 每次循环将会用空闲出来的子进程去调用目标
po.apply_async(worker, (i,)) # 不会因为满了而堵塞全部加入缓存由进程池来调度
print("----start----")
po.close() # 关闭进程池，关闭后po不再接收新的请求
po.join() # 等待po中所有子进程执行完成，必须放在close语句之后
print("-----end-----")
# 通过进程池添加的任务主进程不会等会直接走，这时需要po.join()使主进程等待
if __name__ == "__main__":
main()
总结：
1.通过po = multiprocessing.Pool(最大进程数)创建进程池
2.po.apply_async(进程, (参数,))把进程加入进程池由进程池统一调度。
3.po.close()所有进程添加完毕
4.po.join()等待所有子进程运行完毕
05.小应用
import os
import multiprocessing
def copy_file(file_name, older_file_name, new_file_name):
"""完成文件的复制"""
num = file_name.find(".")
with open(older_file_name+"/"+file_name, "rb") as file1:
data = file1.read()
with open(new_file_name+"/"+file_name[:num]+"[copy]"+file_name[num:], "wb") as file2:
file2.write(data)
def main():
# 1.获取用户要copy的文件夹的名字
older_file_name = input("请输入要拷贝文件夹的名字：")
# 2.创建一个新文件夹
try:
os.mkdir(older_file_name + "[copy]")
except:
print("文件夹存在!")
new_file_name = older_file_name + "[copy]"
# 3.获取用户需要copy所有文件夹里面的所有文件名
file_names = os.listdir(older_file_name)
# 4.创建进程池
p = multiprocessing.Pool(3)
# 5.向进程池中添加copy文件任务
for file_name in file_names:
p.apply_async(copy_file, args=(file_name, older_file_name, new_file_name))
p.close()
p.join()
if __name__ == "__main__":
main()
"""
os.listdir("./test")会返回一个列表
['docker学习笔记.doc', 'Kali安装中文输入法ibus-v2.pdf', 'kivy学习笔记.docx',
'python学习笔记.docx', 'tk窗口学习笔记.docx', '暑假学习计划.docx',
'第1章-安装渗透测试系统Kali-v30.docx',
'第2章-配置本地网络并实现xshell连接kali系统-v50 - VIP.docx']
"""升级版打印进度条
import os
import multiprocessing
def copy_file(queue, file_name, older_file_name, new_file_name):
"""完成文件的复制"""
num = file_name.find(".")
file1 = open(older_file_name+"/"+file_name, "rb")
file2 = open(new_file_name+"/"+file_name[:num]+"[copy]"+file_name[num:], "wb")
while True:
content = file1.read(1024)
if content:
file2.write(content)
else:
break
file1.close()
file2.close()
queue.put(file_name)
def main():
# 1.获取用户要copy的文件夹的名字
older_file_name = input("请输入要拷贝文件夹的名字：")
# 2.创建一个新文件夹
try:
os.mkdir(older_file_name + "[copy]")
except:
print("文件夹存在!")
new_file_name = older_file_name + "[copy]"
# 3.获取用户需要copy所有文件夹里面的所有文件名
file_names = os.listdir(older_file_name)
# 4.创建进程池
p = multiprocessing.Pool(3)
# 5.创建队列,队列链接进程池之间的调用方法：multiprocessing.Manager().Queue()
queue = multiprocessing.Manager().Queue()
# 6.向进程池中添加copy文件任务
for file_name in file_names:
p.apply_async(copy_file, args=(queue, file_name, older_file_name, new_file_name))
p.close()
# p.join()
all_file_num = len(file_names) # 检测文件的个数
while True:
file_name = queue.get()
if file_name in file_names:
file_names.remove(file_name)
copy_rate = (all_file_num-len(file_names))*100/all_file_num
print("\r拷贝的进度为%.2f%%" % copy_rate, end="")
if copy_rate >= 100:
print()
break
if __name__ == "__main__":
main()
3578
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
