El concepto de
proceso Proceso: Proceso se refiere al proceso en ejecución del programa. Es un concepto dinámico (la operación del programa es el proceso de operar la aplicación por el sistema operativo que controla el hardware).
Programa: El programa es una serie de archivos de código, que es un estado estático. Concepto El
proceso es el concepto central del sistema operativo, el proceso de investigación es estudiar el sistema operativo
Historial del sistema operativo
Sistema operativo por lotes-> sistema operativo de tiempo compartido-> multics-> unix-> minix-> linux
La primera generación de computadoras (1940-1955): tubos de vacío y tarjetas perforadas.
Ventajas: los programadores tienen uso exclusivo de todo el recurso durante el período de aplicación y pueden depurar sus propios programas al instante (los errores se pueden solucionar de inmediato)
Desventajas: desperdicio de los recursos informáticos, uno Sólo una persona lo usa durante el período de tiempo. Solo hay un programa en la memoria al mismo tiempo, que es llamado y ejecutado por la CPU, por ejemplo, la ejecución de 10 programas es serial
Computadoras de segunda generación (1955 ~ 1965): transistores y sistema de procesamiento por lotes
Ventajas: sistema de procesamiento por lotes, que ahorra tiempo de la máquina
Desventajas:
1. Todo el proceso requiere la participación humana en el control y la cinta se mueve
2. El proceso de cálculo aún está Cálculo secuencial: "Serie (después de que se ejecuta un programa y luego ejecuta el siguiente programa)
3. La computadora que los programadores solían disfrutar durante un período de tiempo ahora debe estar unificada en un lote de trabajos, y el proceso de esperar resultados y la nueva depuración debe ser la misma Todos los demás programas del lote se pueden completar (esto afecta en gran medida la eficiencia del desarrollo del programa y es imposible depurar el programa a tiempo)
La computadora de tercera generación (1965 ~ 1980): chip de circuito integrado y
tecnología multicanal de diseño multiprograma (IBM) (la tecnología multicanal tiene un sistema operativo para controlar la CPU y realiza la concurrencia)
1. Reutilización espacial: dividir el memoria en varias partes y coloque cada parte en un programa (el espacio de memoria está aislado entre sí), de modo que haya varios programas en la memoria al mismo tiempo.
2. Reutilización de tiempo: varios procesos comparten el tiempo de la CPU, el cambio de CPU hacia adelante y hacia atrás admite múltiples programas para ejecutar la
taza para cambiar rápidamente entre múltiples procesos / tareas
1. En caso de cambio de io
2. Tardará demasiado. Cambiar
Sistema operativo de tiempo compartido:
múltiples terminales en línea + tecnología multicanal.
El científico informático de Bell Labs, Ken Thompson, desarrolló más tarde el sistema Unix.
Más tarde, en 1987, apareció un pequeño clon de UNIX, llamado minix, para uso docente. El estudiante finlandés Linus Torvalds escribió Linux basado en él
Computadora de cuarta generación (1980 ~ presente): computadora personal
Conceptos relacionados de procesos
Concurrencia: varias tareas parecen ejecutarse al mismo tiempo
Paralela: varias tareas se ejecutan al mismo tiempo en un sentido verdadero
Serial: solo después de que se haya ejecutado una tarea se puede iniciar y luego ejecutar la siguiente tarea
Tres estados de la tarea en
ejecución Estado de ejecución: el proceso se está ejecutando normalmente
Estado de bloqueo: el proceso está bloqueado esperando entrada (el programa se lee del disco duro a la memoria)
Estado listo: el proceso está esperando para ejecutarse.
Dos formas de enviar tareas
: 1. Sincrónico: después de enviar una tarea y esperar el resultado de la tarea, luego envíe la siguiente tarea
2. Asíncrono: después de enviar la tarea, sin esperar el resultado de la tarea, envíe directamente la siguiente tarea
Mejore la eficiencia de la operación del proceso y reduzca io. Si puede obtener datos de la memoria, no los obtenga del disco duro. Si puede obtener los datos del local, no los obtenga de la red.
La forma en que el sistema operativo llama a la interfaz. La forma en que el
sistema Windows llama a la interfaz: fork
linux . La forma en que el sistema llama a la interfaz: CreateProcess
importa la clase Process del módulo de multiprocesamiento. Después de encapsular este módulo, resuelve directamente la cruz -Problema de plataforma.
Dos formas de
iniciar un proceso: cada vez que el sistema operativo inicia un proceso hijo, copia los datos del proceso padre en el proceso hijo como los datos iniciales para que se inicie el proceso hijo. Una vez iniciado el proceso, el proceso hijo y el proceso padre no se afectan entre sí.
En el sistema Linux, en el momento en que se inicia el proceso secundario, los datos del proceso hijo es exactamente el mismo que el proceso padre.
En Windows, el proceso hijo también heredará el momento en que se inicia el proceso hijo. Los datos del proceso padre, pero los datos inicializados no son exactamente los mismos.
windows操作系统下 创建进程一定要在main内创建
因为windows下创建进程类似于模块导入的方式
会从上往下依次执行代码
linux系统中是直接将代码完整的拷贝一份
方式一：
from multiprocessing import Process # 从multiprocessing模块中导入Process这个类。这个模块封装好了直接就解决了跨平台性的问题
import os
import time
def task(n):
print("父进程:%s 自己进程:%s 正在运行" % (os.getppid(), os.getpid())) # os.getppid(), os.getpid() 父进程的id ，自己进程的id
time.sleep(n)
print("父进程:%s 自己进程:%s 正在运行" % (os.getppid(), os.getpid()))
if __name__ == "__main__": # 在windows系统下开启子进程必须在该命令下开启
p = Process(target=task, args=(3,)) # 把task任务丢到target这个对象里面去，传参args=（n，）传的必须是一个元组
p.start() # 通知操作系统开启子进程，异步
print("主", os.getpid())
父进程开启子进程的的过程：应用程序调用操作系统接口，操作系统先开辟一个内存空间，再拷贝父进程的数据，在新开辟的内存空间里面开启子进程。
这个过程需要经历的时间远远超过了父进程自己程序运行的时间，根据异步的原则，打印结果为：
主 28572
父进程:28572 自己进程:1128 正在运行
父进程:28572 自己进程:1128 正在运行
方式二：
引入面向对象的概念
from multiprocessing import Process
import os
import time
class Myprocess(Process):
def __init__(self, n):
super().__init__()
self.n = n
def run(self) -> None: # run是不能加参数的
print("父进程:%s 自己进程:%s 正在运行" % (os.getppid(), os.getpid())) # os.getppid(), os.getpid() 父进程的id 自己进程的id
time.sleep(self.n)
print("父进程:%s 自己进程:%s 正在运行" % (os.getppid(), os.getpid()))
if __name__ == "__main__": # 在windows系统下开启子进程必须在该命令下开启
p = Myprocess(3)
p.start() # 通知操作系统开启子进程，异步
print("主", os.getpid())
El espacio de memoria entre procesos es demostración de código aislado
例1：
from multiprocessing import Process # 从multiprocessing模块中导入Process这个类。这个模块封装好了直接就解决了跨平台性的问题
import time
count = 100 # 主进程的值
def task():
global count # global可以将全局名称空间的不可变类型的值改成局部名称空间不可变类型的值
count = 0
if __name__ == "__main__": # 在windows系统下开启子进程必须在该命令下开启
p = Process(target=task)
p.start() # 通知操作系统开启子进程，异步
time.sleep(5)
print("主", count) # 主 100
Método de objeto de proceso
例2（并行代码演示）：
p.jion（）可以让主进程等待子进程运行结束后再运行主进程。
from multiprocessing import Process
import os
import time
def task(n):
print(os.getpid())
time.sleep(n)
if __name__ == '__main__':
p1 = Process(target=task, args=(3,))
p2 = Process(target=task, args=(2,))
p3 = Process(target=task, args=(1,))
start = time.time()
p1.start() # 通知操作系统开启子进程
p2.start() # 通知操作系统开启子进程
p3.start() # 通知操作系统开启子进程
p1.join() # 3
p2.join() # 2
p3.join() # 1 并发同时运行，主进程等待，不影响子进程运行，时间为3.23秒
stop = time.time()
print(stop - start)
例2（串行代码演示）：
from multiprocessing import Process
import os
import time
def task(n):
print(os.getpid())
time.sleep(n)
if __name__ == '__main__':
p1 = Process(target=task, args=(3,))
p2 = Process(target=task, args=(2,))
p3 = Process(target=task, args=(1,))
start = time.time()
p1.start() # 通知操作系统开启子进程
p1.join()
p2.start() # 通知操作系统开启子进程
p2.join()
p3.start() # 通知操作系统开启子进程
p3.join()
p1.join() # 3
p2.join() # 2
p3.join() # 1 串行，p1,p2,p3依次运行，运行完结束之后再运行下一个。统计时间为6.378838539123535
stop = time.time()
print(stop - start)
Visualización de otro código de función
from multiprocessing import Process
import os
import time
def task(n):
print(os.getpid())
time.sleep(n)
if __name__ == '__main__':
p1 = Process(target=task, args=(3,), name="进程1") # 在括号里面添加name= 可以直接改子进程的名字
p1.start()
print(p1.name, p1.pid) # 查看子进程的名字和id
print(p1.is_alive()) # 判端子进程是否存活 True
p1.terminate() # 告诉操作系统强制结束进程
time.sleep(0.01)
print(p1.is_alive())