1. Descripción general del proceso del hilo.
Cada vez que el sistema operativo ejecuta un programa, preparará una memoria para el programa, y luego esta memoria se dedica a almacenar las variables generadas durante la ejecución del programa.
Esta área de memoria se puede considerar como el proceso xxx, y luego hay varios subprocesos en el proceso para ayudarnos a trabajar (al menos uno). Entonces, un proceso es una unidad de recursos, un subproceso es una unidad de ejecución y la CPU ejecuta un subproceso cuando se está ejecutando.
Cuando creamos un proceso, ¿qué pasa si no creamos un hilo? La respuesta es, por supuesto, no. Puede comparar el proceso con una empresa. Para que la empresa funcione, debe haber al menos un empleado (hilo). Cuando se ejecuta el programa, si un hilo no es suficiente, necesita Para crear algunos subprocesos más, este es el concepto de subprocesos múltiples.
Cada vez que se crea un programa, hay un hilo principal en él (principal)
2. A continuación se presenta un caso para ver si es un programa multiproceso.
def func():
for i in range(1000):
print("func",i)
if __name__ == '__main__':
func()
for i in range(1000):
print("main",i)Al observar el proceso de ejecución del programa, cuando se ejecuta el programa, primero genera func, luego regresa a la función func en el hilo principal para ejecutar, y luego regresa a main y luego continúa ejecutándose, por lo que esta es una línea El proceso, de un solo subproceso, no de varios subprocesos.
También se puede ver en los resultados de la ejecución que primero se ejecuta func y luego main.
3. Dos métodos de creación de subprocesos múltiples.
Método 1: importar paquete Thread
# 进程，线程
# 进程是资源单位，每一个进程至少有一个线程
# 线程是执行单位
# 启动每一个程序默认都会有一个主线程
#多线程
from threading import Thread # 线程类
def func():
for i in range(1000):
print("func",i)
if __name__ == '__main__':
#创建线程类对象，并告诉程序你当前的线程，如果要执行的话，要执行谁 。
#target=后面的子线程不能加括号 加括号相当于返回值做参数，不加括号相当于函数本身做参数。
T = Thread(target=func) #创建线程，并给线程分配任务，
'''
Thread相当与公司招了一个新员工，新线程
target=func 相当于告诉新员工，如果你开始执行，你该干什么事情
同时呢，招完员工后自己该干什么事继续去干
'''
T.start() #多线程的状态为可以开始工作状态，具体的执行时间还得由CPU决定
for i in range(1000):
print("main",i)A través de los resultados de la ejecución, se encuentra que la función y los subprocesos principales se ejecutan juntos, debido a que todos los lugares de impresión están en la consola, habrá procesos superpuestos.
Método 2: crea la clase MyThread tú mismo
from threading import Thread # 线程类
class MyThread(Thread): #继承Thread
'''
MyThread是我们自己创建的类，我们的类继承Thread就相当于是Thread的子类
所以我们写的类就会有Thread的特性
（子承父业）
'''
# 重写Thread里的run方法
def run(self): #当线程被执行的时候，被执行的就是run()
for i in range(1000):
print("子线程", i)
if __name__ == '__main__':
T = MyThread()
#T.run() #方法的调用 单线程
T.start() #开启线程
for i in range(1000):
print("主线程",i)El resultado también es el mismo.
4. Creación de subprocesos múltiples (paso de parámetros)
Cuando necesitamos pasar dos hilos, es difícil ver cuál es cuál de la siguiente manera.
from threading import Thread
def func():
for i in range(1000):
print("func",i)
if __name__ == '__main__':
T1 = Thread(target=func)
T1.start()
T2 = Thread(target=func)
T2.start()【resultado de la operación】
La pantalla funciona, no sé cuál es t1 y t2 respectivamente.
En este momento, debe utilizar el método de pasar parámetros. Solo necesita agregar un parámetro (args) para confirmar el nombre del hilo al pasar el hilo, cabe señalar que el valor correspondiente a args debe ser una tupla.
from threading import Thread
def func(name):
for i in range(1000):
print(name,i)
if __name__ == '__main__':
T1 = Thread(target=func,args=("王力宏",)) # 传入参数必须是元组的形式
T1.start()
T2 = Thread(target=func,args=("周杰伦",))
T2.start()De esta forma se puede conocer claramente el nombre de cada hilo.
5. La creación de múltiples procesos.
En comparación con los subprocesos múltiples, el proceso múltiple usará un poco menos, porque abrir un proceso requiere más recursos que abrir un subproceso, porque necesita abrir memoria.
La creación de multiproceso es similar a la de subprocesos múltiples, pero los paquetes importados son diferentes
from multiprocessing import Process #进程类
def func():
for i in range(20000):
print("子进程",i)
if __name__ == '__main__':
P = Process(target=func)
P.start()
for i in range(20000):
print("主进程",i)【resultado de la operación】
