Dado que el uso de subprocesos múltiples implica mucho, se registrará en dos artículos.
Tabla de contenido
2. Ventajas del subproceso múltiple
3. Dos métodos para implementar subprocesos múltiples
(2) Implementar la interfaz Runnable
Procesos e hilos
1. Introducción
Un programa es una colección de instrucciones de computadora y un proceso es un programa en ejecución, que se refiere a un proceso completo desde la carga del código, la ejecución hasta su finalización. Cada proceso ocupa un espacio de memoria diferente.
Un subproceso es un único flujo secuencial de control en un proceso, también conocido como proceso ligero, que es programado por el sistema operativo y se ejecuta en el procesador o kernel. Un proceso tiene un hilo principal, y un proceso también puede estar compuesto por varios hilos. Cada hilo realiza diferentes tareas en paralelo. Estos múltiples hilos comparten un espacio de memoria.
2. Ventajas del subproceso múltiple
(1) La tecnología de subprocesos múltiples hace que el programa responda más rápido
(2) Cuando actualmente no hay ninguna tarea de procesamiento, el tiempo de procesamiento de la CPU se puede asignar a otras tareas.
(3) Las tareas que requieren mucho tiempo de procesamiento de la CPU pueden ceder regularmente tiempo de procesamiento a otras tareas.
(4) Puedes detener la tarea en cualquier momento.
(5) Puede priorizar tareas estableciendo la prioridad de la tarea
3. Dos métodos para implementar subprocesos múltiples
Ambos métodos utilizan la venta de entradas como ejemplo.
(1), heredar hilo
Ventajas: Fácil de escribir. Si necesita acceder al hilo actual, no es necesario utilizar el método Thread.currentThread(). Puede obtener el hilo actual directamente usando este.
Desventajas: debido a que la clase de subproceso ha heredado la clase de subproceso, no puede heredar otras clases principales.
Pasos específicos:
1. Cree una subclase de subprocesos;
2. Anule los métodos de la clase Thread;
3. Cree un objeto de subclase Thread, es decir, cree un objeto thread;
4. Llame al método start () del objeto de hilo para iniciar el hilo, y luego el sistema llamará automáticamente a la implementación específica en el método run () reescrito.
Ejemplo de código:
package Study;
public class Exp03 extends Thread{
int ticket=6;
//重写Thread类的run()方法
public void run(){
//持续卖票。一直到剩余票数为0
while(this.ticket>=0){
System.out.println(this.getName()+"卖票-->"+(this.ticket--));
//对于设置线程名称,Thread类自带getName方法和setName方法。也可以使用构造方法进行设置
}
}
public static void main(String[] args){
Exp03 thread1=new Exp03();
Exp03 thread2=new Exp03();
thread1.setName("窗口1");
thread2.setName("窗口2");
thread1.start(); //线程运行
thread2.start();
}
}Resultados de salida
Cabe señalar que en el ejemplo, se crean y permiten 2 subprocesos y los resultados de salida de varias ejecuciones pueden ser diferentes. Debido a que los subprocesos se ejecutan mediante la programación de subprocesos, muchos subprocesos manejan el estado listo, pero en realidad solo se está ejecutando un subproceso. Por lo tanto, el sistema operativo eliminará un subproceso cuando esté inactivo y permitirá que otros subprocesos lo ejecuten, es decir, programación de subprocesos.
Si se requiere que los subprocesos se ejecuten en el orden en que se llama al programa, se debe determinar si el subproceso anterior terminó antes de la ejecución. Esto aparecerá en la sincronización de hilos discutida en la próxima publicación del blog.
(2) Implementar la interfaz Runnable
Ventajas: la clase de hilo solo implementa la interfaz Runnable y también puede heredar otras clases. Varios subprocesos pueden compartir el mismo objeto de destino, lo cual es muy adecuado para situaciones en las que varios subprocesos idénticos procesan el mismo recurso.
Desventaja: para obtener el hilo actual, debe utilizar el método Thread.currentThread()
Pasos específicos
1. Defina una clase que implemente la interfaz Runnable e implemente el método run ();
2. Cree un objeto Runnable como parámetro de destino de la clase Thread para crear un objeto Thread (el objeto de hilo real);
3. Llame al método start() para iniciar el hilo.
Ejemplos de código (2 ejemplos, el Ejemplo 2 utiliza las ventajas de este método para modificar el Ejemplo 1):
Ejemplo 1:
package Study;
public class Exp03 implements Runnable{
int ticket=6;
//重写Thread类的run()方法
public void run(){
//持续卖票。一直到剩余票数为0
while(this.ticket>=0){
System.out.println(Thread.currentThread().getName()+"卖票-->"+(this.ticket--));
//对于设置线程名称,Thread类自带getName方法和setName方法。也可以使用构造方法进行设置
}
}
public static void main(String[] args){
Exp03 t1=new Exp03(); //创建线程类对象
Exp03 t2=new Exp03();
Thread thread1=new Thread(t1); //创建线程
Thread thread2=new Thread(t2);
thread1.setName("窗口1"); //给线程命名
thread2.setName("窗口2");
thread1.start(); //线程运行
thread2.start();
}
}Resultados de salida
Aprovechando Runnable, modifique la instancia 1 para permitir que varios subprocesos procesen el mismo recurso.
Ejemplo 2:
package Study;
public class Exp03 implements Runnable{
int ticket=6;
//重写Thread类的run()方法
public void run(){
//持续卖票。一直到剩余票数为0
while(this.ticket>=0){
System.out.println(Thread.currentThread().getName()+"卖票-->"+(this.ticket--));
//对于设置线程名称,Thread类自带getName方法和setName方法。也可以使用构造方法进行设置
}
}
public static void main(String[] args){
Exp03 t1=new Exp03(); //创建线程类对象
Thread thread1=new Thread(t1); //创建线程
Thread thread2=new Thread(t1);
thread1.setName("窗口1"); //给线程命名
thread2.setName("窗口2");
thread1.start(); //线程运行
thread2.start();
}
}Resultado de salida:
Se puede ver en los resultados de salida que dos ventanas venden 6 boletos para un objeto t1 al mismo tiempo, por lo que las dos ventanas venden un total de 6 boletos en lugar de los 12 boletos de la instancia 1.
Por lo tanto, es muy adecuado utilizar el método de interfaz Runnable cuando se utilizan subprocesos múltiples para procesar recursos compartidos.