python学习笔记（二十六）python的进程操作

最新推荐文章于 2021-12-31 23:09:10 发布

驻守、流年

最新推荐文章于 2021-12-31 23:09:10 发布

阅读量356

点赞数

分类专栏： python 文章标签：进程操作 python

本文链接：https://blog.csdn.net/qq_38830964/article/details/99549049

版权

python 专栏收录该内容

31 篇文章 3 订阅

订阅专栏

一、单进程

from multiprocessing import Process
import time

#multiprocessing:跨平台版本的多进程模块，提供了一个Process类来代表一个进程对象

def run(str):
	while True:
		print('hello %s...'%(str))
		time.sleep(1.5)


if __name__ == '__main__':
	print('主进程启动')
	# 创建子进程
	# target说明进程执行的任务
	p = Process(target=run,args=("java",))
	# 启动进程
	p.start()
	# 主进程运行
	while True:
		print('I dont want see you anymore...')
		time.sleep(1)

二、启动大量子进程

from multiprocessing import Pool
import time
import os, random


def run(num):
	print('子进程%d启动——%s' % (num, os.getpid()))
	start = time.time()
	# 随机暂停时间
	time.sleep(random.choice([1, 2, 3]))
	end = time.time()
	print('子进程%d结束——%s,耗时：%d' % (num, os.getpid(), end - start))


if __name__ == '__main__':
	print('父进程启动')

	# 创建多个进程
	# 进程池,参数表示可以同时进行的进程数量，默认大小是CPU核心数量
	pc = Pool(3)
	for i in range(5):
		# 创建进程放入进程池统一管理
		pc.apply_async(run, args=(i,))
	# 在调用join之前必须先调用close，调用close之后不能再继续添加新的进程了
	pc.close()
	# 进程池对象调用join，会等待进程池中所有子进程结束完毕再去执行父进程
	pc.join()

	print('父进程结束')

三、全局变量在多个进程中不能共享



from multiprocessing import Process
from time import sleep
num = 100

def run():
	print("子进程开始")
	global num #引入num
	num += 1
	print(num)
	print("子进程结束")

if __name__=="__main__":
	print("父进程开始")

	p = Process(target=run)
	p.start()
	p.join()

	#在子进程中修改全局变量对父进程中的全局变量没有影响
	#在创建子进程时对全局变量做了一个备份，父进程中与子进程中的num是两个完全不同的变量
	print("父进程结束--%d"%num)


'''
运行结果
父进程开始
子进程开始
101
子进程结束
父进程结束--100
'''

四、父子进程之间的先后顺序

from multiprocessing import Process
import time
from time import sleep

def run(str):
	while True:
		print("启动子进程")
		sleep(3)
		print("子进程结束")


if __name__ == '__main__':
	print('主进程启动')

	p = Process(target=run,args=("java",))
	# 启动进程
	p.start()
	#父进程的结束不能影响子进程，让父进程等待子进程结束再执行父进程
	p.join()
	print('父进程结束')

五、进程间通信

from multiprocessing import Queue, Process
import os, time


def write(q):
	print('启动写子进程%s' % os.getpid())
	for chr in ['A', 'B', 'C', 'D']:
		q.put(chr)
		time.sleep(1)
	print('结束写子进程%s' % os.getpid())


def read(q):
	print('启动读子进程%s' % os.getpid())
	while True:
		value = q.get(True)
		print('value:', value)
	print('结束读子进程%s' % os.getpid())


if __name__ == '__main__':
	# 进程间通信，父进程需要创建一个队列，并传递给子进程
	q = Queue()
	pw = Process(target=write, args=(q,))
	pr = Process(target=read, args=(q,))

	pw.start()
	pr.start()
	pw.join()
	# pr进程里是一个死循环，无法等待结束，只能强行结束terminate()，如果写进程结束，那么读进程结束
	pr.terminate()
	print('父进程结束')

六、文件拷贝

1、普通方法实现

import os,time
from multiprocessing import Pool


#实现文件的拷贝
def copyFile(rPath,wPath):
	fr = open(rPath,"rb")
	fw = open(wPath,"wb")
	context = fr.read()
	fw.write(context)
	fr.close()
	fw.close()

path = r"F:\学习存放\untitled\进程与线程\多任务原理\进程"
toPath =r"F:\学习存放\untitled\进程与线程\多任务原理\copy"

#读取path下的全部文件
fileList = os.listdir(path)

#启动for循环处理每一个文件
start = time.time()
for fileName in fileList:
	copyFile(os.path.join(path,fileName),os.path.join(toPath,fileName))

end = time.time()
print("总耗时：%0.2f"%(end-start))

2、多进程方法实现

import os,time
from multiprocessing import Pool


#实现文件的拷贝
def copyFile(rPath,wPath):
	fr = open(rPath,"rb")
	fw = open(wPath,"wb")
	context = fr.read()
	fw.write(context)
	fr.close()
	fw.close()

path = r"F:\学习存放\untitled\进程与线程\多任务原理\进程"
toPath =r"F:\学习存放\untitled\进程与线程\多任务原理\copy"



if __name__ =="__main__":
	# 读取path下的全部文件
	fileList = os.listdir(path)

	start = time.time()
	pp = Pool(2)
	for fileName in fileList:
		pp.apply_async(copyFile,args=(os.path.join(path,fileName),os.path.join(toPath,fileName)))

	pp.close()
	pp.join()
	end = time.time()
	print("总耗时: %0.2f"%(end-start))