由于本人在linux系统上学习
Linux系统如何创建子进程
-
1). Unix/Linux操作系统提供了一个fork()系统调用，它非常特殊。普通的函数调用，
调用一次，返回一次，但是fork()调用一次，返回两次，因为操作系统自动把当前进程（
称为父进程）复制了一份（称为子进程），然后，分别在父进程和子进程内返回。 -
2). 子进程永远返回0，而父进程返回子进程的ID。这样做的理由是，一个父进程可以fork
出很多子进程，所以，父进程要记下每个子进程的ID，而子进程只需要调用getppid() 就可以拿到父进程的ID。 -
3). Python的os模块封装了常见的系统调用，其中就包括fork，可以在Python程序中轻松 创建子进程：
-
原理:
父进程和子进程:, 如果父进程结束， 子进程也随之结束;
先有父进程， 再有子进程. 类Linux系统中(redhat,mac), fork函数; -
常用函数:
os.fork()
os.getpid() # 获取当前进程的pid （process id）
os.getppid() # 获取当前进程的父进程pid (parent process id)
multiprocess跨平台实现多进程
-
1.理解：
如果你打算编写多进程的服务程序，Unix/Linux无疑是正确的选择。由于Windows
没有fork调用，难道在Windows上无法用Python编写多进程的程序？由于Python是跨平台的，自然也应该提供一个跨平台的多进程支持。multiprocessing
模块就是跨平台版本的多进程模块。multiprocessing模块提供了一个Process类来代表一个进程对象，下面的例子演示了
启动一个子进程并等待其结束：
创建子进程时，只需要传入一个执行函数和函数的参数，创建一个Process实例，用start()方法启动，这样创建进程比fork()还要简单。join()方法可以等待子进程结束后再继续往下运行，通常用于进程间的同步。
-
2.Process使用属性及方法
Process 类用来描述一个进程对象。创建子进程的时候，只需要传入一个执行函数和函数的参数即可完成 Process 示例的创建。
star() 方法启动进程，
join() 方法实现进程间的同步，等待所有进程退出。
close() 用来阻止多余的进程涌入进程池 Pool 造成进程阻塞。multiprocessing.Process(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)
target 是函数名字，需要调用的函数
args 函数需要的参数，以 tuple 的形式传入
import multiprocessing
def job():
print("当前子进程的名称%s....." %(multiprocessing.current_process()))
# 通过类的实例化实现
p1 = multiprocessing.Process(target=job, name="我的第一个子进程")
p1.start()
# 通过类的实例化实现
p2 = multiprocessing.Process(target=job, name="我的第2个子进程")
p2.start()
# join方法， 等待所有的子进程执行结束， 再执行主进程
p1.join()
p2.join()
print("任务执行结束.....")
类的继承实现多进程
import multiprocessing
class MyProcess(multiprocessing.Process):
# 重写run方法=====start方法默认执行run方法
def run(self):
print("当前子进程的名称%s....." % (multiprocessing.current_process()))
p1 = MyProcess(name="first")
p1.start()
p2 = MyProcess(name="second")
p2.start()
p1.join()
p2.join()
print("all finish.....")
多进程案例效率演示
import threading
import time
from day21.mytimeit import timeit
import multiprocessing
def job(li):
return sum(li)
@timeit
def use_thread():
li = range(1, 100000000)
# create 5 threads
threads = []
for i in range(5):
t = threading.Thread(target=job, args=(li, ))
t.start()
threads.append(t)
[thread.join() for thread in threads]
@timeit
def use_no_thread():
li = range(1, 100000000)
for i in range(5):
job(li)
@timeit
def use_process():
li = range(1, 100000000)
# create 5 threads
processes = []
# 1). 开启的进程书是有瓶颈的， 取决于CPU个数,
# 2). 如果处理的数据比较小， 不建议使用多进程,因为创建进程和销毁进程需要时间;
# 3). 如果处理数据足够大， 0《进程数《cpu个数;
for i in range(5):
p = multiprocessing.Process(target=job, args=(li,))
p.start()
processes.append(p)
[process.join() for process in processes]
if __name__ == "__main__":
use_thread()
use_process()
use_no_thread()
进程锁
使用进程锁:
import multiprocessing
def work(f, item, lock):
lock.acquire()
try:
with open(f, 'a+') as f:
f.write("a %s task\n" % (item))
except Exception as e:
print("产生异常...")
finally:
lock.release()
def main():
# 1). 实例化一个进程锁
lock = multiprocessing.Lock()
filename = 'doc/my.log'
processes = []
for i in range(4):
p1 = multiprocessing.Process(target=work, args=(filename, i,lock))
p1.start()
processes.append(p1)
[process.join() for process in processes]
if __name__ == '__main__':
main()
未使用进程锁:会导致写入文件错乱
import multiprocessing
def work(f, item):
try:
with open(f, 'a+') as f:
f.write("a %s task\n" % (item))
except Exception as e:
print("产生异常...")
def main():
filename = 'doc/my.log'
processes = []
for i in range(4):
p1 = multiprocessing.Process(target=work, args=(filename, i))
p1.start()
processes.append(p1)
[process.join() for process in processes]
if __name__ == '__main__':
main()
进程池第一种实现方式
- 在使用Python进行系统管理时，特别是同时操作多个文件目录或者远程控制多台主机，
并行操作可以节约大量时间，如果操作的对象数目不大时，还可以直接适用Process类动态
生成多个进程，几十个尚可，若上百个甚至更多时，手动限制进程数量就显得特别繁琐， 此时进程池就显得尤为重要。 - 进程池Pool类可以提供指定数量的进程供用户调用，当有新的请求提交至Pool中时，
若进程池尚未满，就会创建一个新的进程来执行请求；若进程池中的进程数已经达到
规定的最大数量，则该请求就会等待，直到进程池中有进程结束，才会创建新的进程来 处理该请求。
import multiprocessing
def job(id):
print("start %d...." % (id))
print("end %d...." % (id))
# 创建进程池对象
pool = multiprocessing.Pool(processes=4)
# 给进程池分配任务;
for i in range(10):
pool.apply_async(job, args=(i + 1,))
pool.close()
# 等待所有的子进程执行结束， 关闭进程池对象;
pool.join()
print("所有任务执行结束.....")
进程池的第二种实现方式
from concurrent.futures import ProcessPoolExecutor
def job(id):
print("start %d...." % (id))
print("end %d...." % (id))
pool = ProcessPoolExecutor(max_workers=4)
#
# for id in range(10):
# # 分配任务给子进程， 并且返回一个Future对象;
# f1 = pool.submit(job, args=(id))
# # 判断子进程是否执行结束?
# print(f1.done())
# # 查看该子进程执行的结果
# print(f1.result())
pool.map(job, range(10))
多进程拷贝文本文件
拷贝的原理:
1). 读取源文件的内容;
2). 写入新的文件中;
import os
import time
import multiprocessing # 进行进程间的通信, Queue
from queue import Queue
def copyFileTask(oldFolderName, newFolderName, filename, queue):
"""
import os
# 拼接生成绝对路径
os.path.join('/mnt', 'file')
'/mnt/file'
os.path.join('/mnt/', 'file')
'/mnt/file'
:param oldFolderName: /root/day21/
:param newFolderName: /root/day21_backup_201901
:param filename: file1
:return:
"""
# 两者相同的效果， with语句执行节航速后， 自动关闭文件对象;
# with open('/etc/passwd') as f:
# pass
# f = open('/etc/passwd')
# with f:
# pass
fr = open(os.path.join(oldFolderName, filename), 'rb')
fw = open(os.path.join(newFolderName, filename), 'wb')
with fr, fw:
content = fr.read(1024*3)
while content:
fw.write(content)
queue.put(filename)
# print(queue.qsize())
def main():
# 判断备份目录是否存在
while True:
# oldFolderName = input("请输入备份的目录名:")
oldFolderName ="/var/log/"
if os.path.exists(oldFolderName):
break
dateName = time.strftime('_%Y_%m_%d_%H_%M') # '2019_01_20'
newFolderName = oldFolderName + '_备份' + dateName
if os.path.exists(newFolderName):
os.rmdir(newFolderName)
# 新建备份的目录;
os.mkdir(newFolderName)
print("正在创建备份目录%s....." % (newFolderName))
# 获取备份目录中的所有文件名;
fileNames = os.listdir(oldFolderName)
# 队列， 存储已经备份的文件;
# ****如果是用进程池，那么就需要使用Manager().Queue()队列才能在各子进程间通信，否则沒用
queue = multiprocessing.Manager().Queue()
# queue = Queue()
pool = multiprocessing.Pool(4)
for name in fileNames:
# 给进程池分配任务
pool.apply_async(copyFileTask, args=(oldFolderName,
newFolderName,
name,
queue))
# 100个文件, 1个文件 1%
num = 0 # 当前备份的文件数
allNum = len(fileNames) # 总备份的文件数
# print(num, allNum)
while num < allNum:
# print(queue.qsize())
queue.get()
num += 1
copyRate = num / allNum # 0.2322
# \r使得光标不换行;
print("\r\r备份的进度为%.2f%%" % (copyRate * 100), end='')
pool.close()
pool.join()
print("备份成功;")
if __name__ == '__main__':
main()
第二种
import os
import time
import multiprocessing # 进行进程间的通信, Queue
from queue import Queue
from concurrent.futures import ProcessPoolExecutor
def copyFileTask(oldFolderName, newFolderName, filename, queue):
"""
import os
# 拼接生成绝对路径
os.path.join('/mnt', 'file')
'/mnt/file'
os.path.join('/mnt/', 'file')
'/mnt/file'
:param oldFolderName: /root/day21/
:param newFolderName: /root/day21_backup_201901
:param filename: file1
:return:
"""
# 两者相同的效果， with语句执行节航速后， 自动关闭文件对象;
# with open('/etc/passwd') as f:
# pass
# f = open('/etc/passwd')
# with f:
# pass
fr = open(os.path.join(oldFolderName, filename), 'rb')
fw = open(os.path.join(newFolderName, filename), 'wb')
with fr, fw:
content = fr.read(1024 * 3)
while content:
fw.write(content)
queue.put(filename)
# print(queue.qsize())
def main():
# 判断备份目录是否存在
while True:
oldFolderName = input("请输入备份的目录名:")
# oldFolderName = "/var/log/"
if os.path.exists(oldFolderName):
break
else:
print("%s目录不存在" % (oldFolderName))
dateName = time.strftime('_%Y_%m_%d_%H_%M') # '2019_01_20'
newFolderName = oldFolderName + '_备份' + dateName
if os.path.exists(newFolderName):
# os.rmdir(newFolderName) # 删除空目录
# os.removedirs(newFolderName)
os.system('rm -fr %s' %(newFolderName))
# 新建备份的目录;
os.mkdir(newFolderName)
print("正在创建备份目录%s....." % (newFolderName))
# 获取备份目录中的所有文件名;
fileNames = os.listdir(oldFolderName)
# 队列， 存储已经备份的文件;
# ****如果是用进程池，那么就需要使用Manager().Queue()队列才能在各子进程间通信，否则沒用
queue = multiprocessing.Manager().Queue()
# queue = Queue()
# pool = multiprocessing.Pool(4)
pool = ProcessPoolExecutor(4)
for name in fileNames:
# 给进程池分配任务
# pool.apply_async(copyFileTask, args=(oldFolderName,
# newFolderName,
# name,
# queue))
pool.submit(copyFileTask, oldFolderName, newFolderName, name, queue)
# 100个文件, 1个文件 1%
num = 0 # 当前备份的文件数
allNum = len(fileNames) # 总备份的文件数
# print(num, allNum)
while num < allNum:
# print(queue.qsize())
queue.get()
num += 1
copyRate = num / allNum # 0.2322
# \r使得光标不换行;
print("\r\r备份的进度为%.2f%%" % (copyRate * 100), end='')
print("备份成功;")
if __name__ == '__main__':
main()
1028
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
