Directorio de artículos
Prefacio
A través de este artículo, primero aclare los cinco estados que existen en el subproceso, y luego use el conocimiento previamente aprendido de clases internas anónimas para implementar el subproceso, y luego introduzca el concepto de grupo de subprocesos en multiproceso e introduzca los tres métodos de implementación del grupo de subprocesos en combinación con el código Finalmente, comprenda el concepto de temporizadores en multiproceso y combine dos piezas de código para mostrarle cómo utilizar temporizadores.
Uno, el estado del hilo
- Cinco estados
- Nuevo : se crea el hilo
- Listo : tiene la calificación de ejecución de la CPU, pero no tiene el derecho de ejecución de la CPU
- Operación : tiene la calificación de ejecución de la CPU y el derecho de ejecución de la CPU
- Bloqueo : no tiene la calificación de ejecución de la CPU, ni el derecho de ejecución de la CPU
- Muerte : no tiene la calificación de ejecución de la CPU, ni el derecho de ejecución de la CPU
- Diagrama de estado de ejecución del hilo
Dos, use la clase interna anónima para iniciar el hilo
1. Método de ejecución 1
- Código básico
new Thread(){
@Override
public void run() {
System.out.println("线程1执行了");
}
}.start();
- Llame a la estructura parametrizada para pasar el nombre
new Thread("线程2"){
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"执行了");
}
}.start();
2. Implementación 2
- Código básico
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("线程3执行了");
}
}).start();
- Llame a la estructura parametrizada para pasar el nombre
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"执行了");
}
},"线程4").start();
Tres, el concepto y la implementación del grupo de subprocesos
1. El concepto de grupo de subprocesos
- El costo del programa para iniciar un nuevo hilo es relativamente alto, porque está diseñado para interactuar con el sistema operativo. Y cuando se utiliza el grupo de subprocesos puede proporcionar un mejor rendimiento, especialmente cuando el programa en el que desea crear una gran cantidad de subprocesos de corta duración debe considerar el uso del grupo de subprocesos .
- El grupo de subprocesos es en realidad un contenedor que puede ayudarnos a crear una cierta cantidad de objetos de subprocesos。
- Una vez que finaliza el código de cada subproceso en el grupo de subprocesos, no morirá, sino que regresará al grupo de subprocesos llamado estado inactivo, esperando que se use el siguiente objeto .
2. 3 formas de implementar el grupo de subprocesos
- Antes de JDK5, teníamos que implementar manualmente nuestro propio grupo de subprocesos. A partir de JDK5, Java tiene soporte integrado para grupos de subprocesos.
- JDK5 agregó una nueva clase de fábrica Ejecutores para generar un grupo de subprocesos, hay varios métodos de la siguiente manera.
1. Método uno de implementación del grupo de subprocesos
- public static ExecutorService newCachedThreadPool ()
crea el número de subprocesos correspondientes al subproceso de acuerdo con el número de tareas(Número de tareas = número de hilos) - Código:
public class 线程池实现方式1 {
public static void main(String[] args) {
//通过工厂类，获取线程池对象
ExecutorService executorService = Executors.newCachedThreadPool();
//给线程池中提交任务（根据任务数量，创建线程个数）
//创建了3个线程完成3个任务
executorService.submit(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println(Thread.currentThread().getName() +"执行任务1");
}
}
});
executorService.submit(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println(Thread.currentThread().getName()+"执行任务2");
}
}
});
executorService.submit(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println(Thread.currentThread().getName() + "执行任务3");
}
}
});
//关闭线程池
executorService.shutdown();
}
}
2. Modo dos de implementación del grupo de subprocesos
- public static ExecutorService newFixedThreadPool (int nThreads)
inicializa fijamente el número especificado de subprocesos(El número de subprocesos se especifica arbitrariamente) - Código
public class 线程池的实现方式2 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//固定初始化3个线程
ExecutorService executorService = Executors.newFixedThreadPool(3);
//可以传递callable任务,可以获得线程执行完后的结果
Future<Integer> future =executorService.submit(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
System.out.println("线程执行了");
return 100;
}
});
//获取线程执行结果的返回值
Integer integer = future.get();
System.out.println(integer);
}
}
3. Modo de implementación tres del grupo de subprocesos
- public static ExecutorService newSingleThreadExecutor ()
inicializa un grupo de subprocesos(El número de hilos es 1) - Código:
public class 线程池的实现方式3 {
public static void main(String[] args) {
//初始化一个线程的线程池
ExecutorService executorService = Executors.newSingleThreadExecutor();
executorService.submit(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"执行了任务1");
}
});
executorService.submit(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "执行了任务2");
}
});
executorService.submit(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "执行了任务3");
}
});
//注意：该三个任务都是由一个线程完成的
}
}
Cuarto, el temporizador
-
El temporizador es una herramienta de subprocesos muy utilizada que se puede utilizar para programar varias tareas cronometradas para que se ejecuten en segundo plano.
-
En Java, puede usar Clase de tiempo con Clase TimeTask Cumplir la función de definir la programación.
-
Temporizador:
- temporizador público ()
- horario de anulación pública (tarea TimerTask, retraso prolongado):
- horario de anulación pública (tarea TimerTask, retraso prolongado, período prolongado);
- horario de anulación pública (tarea TimerTask, fecha y hora):
- programación de anulación pública (tarea TimerTask, fecha firstTime, período largo):
-
TimerTask: tarea de cronometraje
- ejecución vacía abstracta pública ()
- public boolean cancel ()
Ejemplo de código 1:
public class 定时器 {
public static void main(String[] args) {
//timer类，是一种工具，线程用其安排以后在后台线程中执行的任务，可以安排任务执行一次，或者定期重复执行。
Timer t1 = new Timer();
//等待多少毫秒之后，执行定时任务
TimerTask task=new TimerTask() {
@Override
public void run() {
System.out.println("爆炸");
}
};
//任务等待5秒执行，1秒不间断执行一次
t1.schedule(task,1000*5,1000);
//取消定时器
//t1.cancel();
//取消任务
//task.cancel();
}
}
Ejemplo de código 2:
public class 定时器2 {
public static void main(String[] args) throws ParseException {
Timer timer = new Timer();
String dateStr="2021-01-23 13:00:00";
Date date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(dateStr);
//使用匿名内部类创建TimeTask
timer.schedule(new TimerTask() {
@Override
public void run() {
System.out.println("从今日起，每日13：00疫情填报");
}
},date,1000*60*60*24);
}
}