cada blog, cada lema: Ilumina el mañana con el hoy.
0. Prefacio
Esta sección realiza experimentos y resume el multiproceso en Python.
Sugerencia: primero mire el concepto de multiproceso, esta sección no repetirá el concepto, haga clic en mí
1. Texto
1.1 Decorador
Decorador, utilizado para ver el tiempo de ejecución de la función, haga clic en mí
import threading
import time
import functools
from multiprocessing import Process
c = 0
def count_time(func):
"""装饰器：计算程序运行时间"""
@functools.wraps(func)
def wrapper(*args, **kwargs):
t1 = time.time()
res = func(*args, **kwargs)
t2 = time.time()
# 计算时间
time_consumed = t2 - t1
print('{}函数一共花费了{}秒'.format(func.__name__, time_consumed))
return res
return wrapper
1.2 Parte de prueba multiproceso
1.2.1 La función probada es dos funciones
La función probada es la siguiente:
@count_time
def mop_floor(arg):
"""拖地操作，"""
global c
print('开始拖地……')
for i in range(3):
time.sleep(1)
c += 5
c -= 5
print('{} is running……c={} !!'.format(arg, c))
print('---------地拖完了！-----------')
@count_time
def heat_water(arg):
"""烧水操作"""
global c
print('我要烧水了……')
for i in range(4):
time.sleep(1)
print('{} is running……c={} !!'.format(arg, c))
print('------------水烧开了！-------------')
1>. Proceso único
Función de proceso único:
@count_time
def single_processing():
"""单进程"""
# 对两个函数进行测试
mop_floor('1')
heat_water('2')
print('-' * 100)
Función principal:
def main():
# 单进程
single_processing()
if __name__ == '__main__':
main()
Resultados de ejecución de un solo proceso:
2>. Multiproceso
Función multiproceso
@count_time
def my_processing():
p1 = Process(target=mop_floor, args=('1',))
p2 = Process(target=heat_water, args=('2',))
p1.start()
p2.start()
p1.join()
p2.join()
# -----------------------------------------
# process_array = {}
# n = 1
# for tid in range(n):
# t = Process(target=single_func_tested, args=('1',))
# t.start()
# process_array[tid] = t
# for i in range(n):
# process_array[i].join()
print('-' * 100)
Función principal
def main():
# 多进程
my_processing()
if __name__ == '__main__':
main()
Como resultado, se puede ver que el tiempo total se reduce
1.2.2 La función bajo prueba es una función computacional
Función bajo prueba
@count_time
def single_func_tested(arg):
"""对一个函数进行测试"""
sum = 0
for i in range(10000000): # 100000
sum += i
print('{} over'.format(arg))
1>. Proceso único
Función de proceso único
@count_time
def single_processing():
"""单进程"""
# 对一个函数进行测试
single_func_tested('1')
print('-' * 100)
Función principal:
def main():
# 单进程
single_processing()
# 多进程
# my_processing()
if __name__ == '__main__':
main()
Resultados del cálculo de un solo proceso:
2>. Multiproceso
Función multiproceso
@count_time
def my_processing():
process_array = {
}
n = 1
for tid in range(n):
t = Process(target=single_func_tested, args=('1',))
t.start()
process_array[tid] = t
for i in range(n):
process_array[i].join()
print('-' * 100)
Función principal:
def main():
# 多进程
my_processing()
if __name__ == '__main__':
main()
Cuando n = 1,
cuando n = 2,
cuando n = 3,
cuando n = 4,
cuando n = 5,
resumen:
- Cuando n <= 4, el tiempo total de ejecución del programa no cambia. Esto se debe a que la máquina experimental tiene 4 núcleos, por lo que cuando hay menos de 4 procesos, los núcleos son suficientes. Cuando n> 4, el tiempo de ejecución del programa aumenta. El número de procesos abiertos supera el número de núcleos.
- Las condiciones para abrir el proceso son múltiples CPU o una CPU tiene múltiples núcleos
- El proceso múltiple para un solo programa no acortará el tiempo de ejecución del programa, solo ejecute un solo programa unas cuantas veces más
1.2.3 La función que se está probando es una función de espera
Función bajo prueba
@count_time
def mop_floor(arg):
"""拖地操作，"""
global c
print('开始拖地……')
for i in range(3):
time.sleep(1)
c += 5
c -= 5
print('{} is running……c={} !!'.format(arg, c))
print('---------地拖完了！-----------')
1>. Proceso único
Función de proceso único
@count_time
def single_processing():
"""单进程"""
# 对两个函数进行测试
mop_floor('1')
# heat_water('2')
# 对一个函数进行测试
# single_func_tested('1')
print('-' * 100)
Función principal
def main():
# 单进程
single_processing()
if __name__ == '__main__':
main()
resultado:
2>. Multiproceso
Función multiproceso:
@count_time
def my_processing():
n = 1
for tid in range(n):
t = Process(target=mop_floor, args=('1',))
t.start()
process_array[tid] = t
for i in range(n):
process_array[i].join()
print('-' * 100)
Función principal:
def main():
# 多进程
my_processing()
if __name__ == '__main__':
main()
Cuando n = 1,
cuando n = 2,
cuando n = 3,
cuando n = 4,
cuando n = 5,
cuando n = 8,
resumen:
- Cuando la teoría del proceso excede la teoría central, el tiempo total de ejecución aumenta ligeramente y el aumento no es tan obvio como la función computacional .
- El proceso múltiple para un solo programa no acortará el tiempo de ejecución del programa, solo ejecute un solo programa unas cuantas veces más
lo anterior.
para resumir:
- Las condiciones para abrir múltiples procesos son múltiples CPU o 1 CPU de múltiples núcleos
- Abra múltiples procesos para un solo programa, sin efecto
1.3 Código fuente
https://gist.github.com/onceone/f5489dcc1499c81ee0161f0ea3bb442b
referencias
[1] https://blog.csdn.net/weixin_39190382/article/details/107107980
[2] http://www.uml.org.cn/python/201901221.asp
[3] https: //www.jianshu .com / p / 644dbb6d4cc8
[4] https://blog.csdn.net/m0_37324740/article/details/85765167
[5] https://www.cnblogs.com/-qing-/p/11291581.html
[6 ] https://blog.csdn.net/lzy98/article/details/88819425
[7] https://www.cnblogs.com/yssjun/p/11302500.html
[8] https://www.jb51.net /article/167165.htm
[9] https://blog.csdn.net/weixin_44850984/article/details/89165731
[10] https://www.cnblogs.com/justbreaking/p/7218909.html?utm_source=itdadao&utm_medium = referencia