1, Python programación concurrente desde una perspectiva de rendimiento En la programación concurrente

• prefacio
• El concepto básico de la programación concurrente
• VS VS sola-hilo multi-proceso multi-hilo
• Comparación de rendimiento Resumen de los resultados

prefacio

Como una rama de la serie Advanced 并发编程"" Creo que esto es todo programador debe estar en.

并发编程 Esta serie, que prepara durante casi una semana, peinando el conocimiento, para pensar lo que quieres citar un ejemplo con el fin de entender más a fondo este conocimiento hace que sea más fácil de detectar. Esperanza de que la presentación de los resultados realmente como lo imaginó, demasiado amistoso con el blanco.

Ayer acabado más o menos esta serie probablemente diría lo siguiente (esta última puede ajustar):

Esquema del curso

Para la programación concurrente, las implementaciones de Python, resumió lo que, más o menos las tres formas siguientes:

• multihilo
• Multiproceso
• Coroutine (generador)

En los siguientes capítulos, estaremos tras otro para informarle sobre estos tres puntos de conocimiento.

El concepto básico de la programación concurrente

Antes de empezar a explicar la teoría del conocimiento, tenía una mirada a algunos conceptos básicos. Aunque es curso avanzado, pero también quiero escribir más blanco, más fácil de usar.

串行: Una persona a la vez sólo puede hacer una cosa, como por ejemplo después de la cena para ver la televisión;
并行: un hombre en el mismo período de tiempo puede ser más o cosa, por ejemplo, se puede comer mientras ve la televisión;

En Python, 多线程 y  协程 aunque estrictamente hablando es una serie, pero más alto que el promedio de eficiencia de la ejecución del programa en serie muy.
programa de serie en general, cuando el programa se bloquea y sólo puede esperar, no puedo hacer otras cosas. Al igual, se emitió en la serie de televisión, en el tiempo de publicidad, no podemos aprovechar el tiempo de publicidad a comer una comida. Para el programa, esto es claramente una eficiencia muy baja, no es razonable.

Por supuesto, después de la finalización de este curso, entendemos que el uso del tiempo de publicidad para hacer otras cosas, horario flexible. Es por ello que 多线程, y 协程 que queremos que nos ayude a lograr cosas, las tareas de gestión racionales internos, por lo que la eficiencia programa máximo.

Si bien  多线程 y  协程 bastante inteligente. Pero todavía no lo suficientemente eficaz, debe ser la multitarea más eficiente, comer viendo la televisión en el chat. Esta es nuestra  多进程 capacidad de hacer cosas.

Para ayudar a entender mejor más intuitiva para encontrar las dos imágenes en Internet, que se explica claramente la diferencia entre multiproceso y multihilo. (Invasion suprimido)

• 多线程Alternativamente ejecutado, la serie en otro sentido.

  

• 多进程, En paralelo, concurrente en el verdadero sentido.

  

. VS sola-hilo multi-proceso multi-hilo VS

Texto siempre pálido, no tan bueno como mil palabras unas pocas líneas de código vienen Kongwuyouli.

En primer lugar, la configuración de mi entorno de prueba es el siguiente

sistema operativo	El número de núcleos de CPU	Memoria (G)	disco duro
CentOS 7.2	24 nucleares	32	disco duro mecánico

Tenga en cuenta que
el siguiente código, para entender, para tener la certeza de que los puntos blancos:

1. Utilizar el decorador
2. uso básico multihilo
3. El uso básico de múltiples procesos

Por supuesto, no entienden que no importa, la conclusión principal, permitir que todos, multi-threaded, multi-proceso tiene una clara comprensión del efecto general sobre la realización del hilo simple, para lograr este efecto, la misión de este artículo está terminado, espere hasta el último , aprender las series completas, tal vez desee volver alrededor y entender que puede haber una comprensión más profunda.

Veamos, de un solo hilo, multi-hilo y multi-proceso, ya sea fuerte o débil en funcionamiento.

Antes de empezar a comparar, primero definir cuatro tipos de escenarios

• cómputo intensivo de la CPU
• S de disco intensiva
• red IO-intensiva
• IO analógico intensiva []

¿Por qué estos tipos de escenarios, y esto 多线程 多进程se aplica a una escena. En conclusión, permítanme explicar.

# CPU计算密集型
def count(x=1, y=1):
    # 使程序完成150万计算
    c = 0
    while c < 500000:
        c += 1
        x += x
        y += y


# 磁盘读写IO密集型
def io_disk():
    with open("file.txt", "w") as f:
        for x in range(5000000):
            f.write("python-learning\n")


# 网络IO密集型
header = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.139 Safari/537.36'}
url = "https://www.tieba.com/"

def io_request():
    try:
        webPage = requests.get(url, headers=header)
        html = webPage.text
        return
    except Exception as e:
        return {"error": e}


# 【模拟】IO密集型
def io_simulation():
    time.sleep(2)

los indicadores de competencia, que utilizan el tiempo para considerar. Cuanto menos tiempo pasó, mayor será la eficiencia.

Para mayor comodidad, hace que el código sea más concisa, estoy aquí es definir un simple  时间计时器 decorador.
Si no está muy comprensivo del decorador, no importa, siempre y cuando usted sabe para qué se utiliza para calcular en función del tiempo en él.

def timer(mode):
    def wrapper(func):
        def deco(*args, **kw):
            type = kw.setdefault('type', None)
            t1=time.time()
            func(*args, **kw)
            t2=time.time()
            cost_time = t2-t1
            print("{}-{}花费时间：{}秒".format(mode, type,cost_time))
        return deco
    return wrapper

El primer paso, echar un vistazo a un único subproceso

@timer("【单线程】")
def single_thread(func, type=""):
    for i in range(10):
              func()

# 单线程
single_thread(count, type="CPU计算密集型")
single_thread(io_disk, type="磁盘IO密集型")
single_thread(io_request,type="网络IO密集型")
single_thread(io_simulation,type="模拟IO密集型")

Mira los resultados

【单线程】-CPU计算密集型花费时间：83.42633867263794秒
【单线程】-磁盘IO密集型花费时间：15.641993284225464秒
【单线程】-网络IO密集型花费时间：1.1397218704223633秒
【单线程】-模拟IO密集型花费时间：20.020972728729248秒

El segundo paso, vistazo a la multi-roscado

@timer("【多线程】")
def multi_thread(func, type=""):
    thread_list = []
    for i in range(10):
        t=Thread(target=func, args=())
        thread_list.append(t)
        t.start()
    e = len(thread_list)

    while True:
        for th in thread_list:
            if not th.is_alive():
                e -= 1
        if e <= 0:
            break

# 多线程
multi_thread(count, type="CPU计算密集型")
multi_thread(io_disk, type="磁盘IO密集型")
multi_thread(io_request, type="网络IO密集型")
multi_thread(io_simulation, type="模拟IO密集型")

Mira los resultados

【多线程】-CPU计算密集型花费时间：93.82986998558044秒
【多线程】-磁盘IO密集型花费时间：13.270896911621094秒
【多线程】-网络IO密集型花费时间：0.1828296184539795秒
【多线程】-模拟IO密集型花费时间：2.0288875102996826秒

El tercer paso es buscar en el último proceso de múltiples

@timer("【多进程】")
def multi_process(func, type=""):
    process_list = []
    for x in range(10):
        p = Process(target=func, args=())
        process_list.append(p)
        p.start()
    e = process_list.__len__()

    while True:
        for pr in process_list:
            if not pr.is_alive():
                e -= 1
        if e <= 0:
            break

# 多进程
multi_process(count, type="CPU计算密集型")
multi_process(io_disk, type="磁盘IO密集型")
multi_process(io_request, type="网络IO密集型")
multi_process(io_simulation, type="模拟IO密集型")

Mira los resultados

【多进程】-CPU计算密集型花费时间：9.082211017608643秒
【多进程】-磁盘IO密集型花费时间：1.287339448928833秒
【多进程】-网络IO密集型花费时间：0.13074755668640137秒
【多进程】-模拟IO密集型花费时间：2.0076842308044434秒

Comparación de rendimiento del resumen de resultados

Los resultados se resumen que, tabulada.

especies	cómputo intensivo de la CPU	S de disco intensiva	red IO-intensiva	Analógico-IO intensiva
Single-roscado	83.42	15.64	1.13	20.02
multihilo	93.82	13.27	0.18	2.02
Multiproceso	9.08	1.28	0.13	2.01

Tenemos que analizar esta forma.

En primer lugar CPU密集型, para comparar multi-hilo de un solo hilo, no sólo ninguna ventaja, al parecer debido a la liberación del bloqueo GIL bloqueo global en curso, el cambio de hilos y, y multi-proceso ineficiente consume mucho tiempo, ya que es más de una CPU en los mismos cálculos de tiempo , el equivalente de diez personas que hacen el trabajo de un hombre, al parecer, la eficiencia está creciendo exponencialmente.

A continuación, el IO-intensivos, IO密集型puede ser 磁盘IO, 网络IO, 数据库IOy así sucesivamente, todos pertenecen a la misma clase, se calcula la cantidad es muy pequeña, sobre todo una pérdida de tiempo de espera para IO. A través de la observación, podemos encontrar nuestro disco IO, red de datos IO, multi-hilo comparación un único subproceso no refleja la gran ventaja de. Esto se debe a la tarea IO de nuestro programa no es pesado, por lo que la ventaja no es evidente.

Así que también añadí un 模拟IO密集型"" uso sleeppara simular el tiempo de espera IO es reflejar las ventajas de multi-threading, sino que también nos permite una comprensión más intuitiva de trabajo de proceso multi-roscado. Cada hilo tiene que ser un solo hilo sleep(2), el hilo es 10 20s, y multi-roscado, en sleep(2)vez, cambiará a otro hilo, de modo que 10 hilos al mismo tiempo sleep(2), era sólo el 10 hilos finales 2s.

Las siguientes conclusiones pueden extraerse

• Siempre el más lento, multi-proceso de un solo subproceso es siempre el más rápido.
• Adecuado para su uso en multi-hilo escenas IO-intensivos, como los reptiles, desarrollo de sitios web
• Adecuado para uso en varios procesos en los calcula CPU los escenarios operacionales altos requeridos, tales como una gran análisis de datos, la máquina de aprendizaje
• Aunque multi-proceso es siempre el más rápido, pero no necesariamente la mejor opción, ya que requiere con el fin de conseguir las ventajas de los recursos de CPU inferior a la ayuda