La copia del código es la siguiente:
paquete com.yao;
import java.util.concurrent.callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.executorservice;
import java.util.concurrent.executors;
import java.util.concurrent.future;
import java.util.concurrent.scheduledExecutorService;
import java.util.concurrent.timeunit;
/**
* Nueva arquitectura de ejecución de tareas.
* Antes de Java 5.0, se inició una tarea llamando al método Start () de la clase de subprocesos.
* El envío y la ejecución de la tarea se llevan a cabo simultáneamente.
* O controlar el número de subprocesos ejecutados simultáneamente requiere un código adicional para completar.
* 5.0 proporciona una nueva arquitectura de ejecución de tareas que le permite programar y controlar fácilmente la ejecución de tareas.
* Y se puede establecer un grupo de hilos similar a un grupo de conexión de base de datos para realizar tareas.
* Esta arquitectura consta principalmente de tres interfaces y sus clases específicas correspondientes.
*Estas tres interfaces son Ejecutor, EjecutorService y ProgramedExecutorService.
* (1) Interfaz del ejecutor: se utiliza para ejecutar tareas ejecutables, solo define un método:
* ejecutar (comando runnable): ejecutar tareas de tipo ruannable
* (2) EjecutorService: hereda el método del Ejecutor y proporciona servicios para ejecutar tareas invocables y abortar la ejecución de tareas.
* Los principales métodos de su definición son:
* Enviar (tarea): se puede usar para enviar tareas llamables o ejecutables y devolver el objeto futuro que representa esta tarea
* InvokeAll (Colección de tareas): recopilación de tareas por lotes y devuelve una colección de objetos futuros que representan estas tareas.
* apagado (): cierre el servicio después de completar la tarea enviada y ya no acepta nuevas tareas.
* shutdownNow (): detiene todas las tareas de ejecución y cierra el servicio.
* se termina (): prueba si todas las tareas han sido ejecutadas.
* isshutdown (): prueba si el servicio de ejecutor se ha cerrado
* (3) ProgramedExecutorService: hereda el servicio de ejecutores, proporcionando la función de la programación de tareas según el tiempo,
* Programa (tarea, initDelay): Programe la tarea presentable o ejecutable enviada para ser ejecutada después del tiempo especificado por InitDelay.
* ScheduleAtFixedRate (): Programe la tarea ejecutable enviada para ser ejecutada repetidamente en el intervalo especificado.
* SchedulewithFixedDelay (): Programe la tarea ejecutable enviada para ser ejecutada repetidamente después de cada ejecución, espere el tiempo especificado por demora.
*
* Obtenga varios objetos de servicio a través de la clase Ejecutores.
* Callable (Tarea Runnable): Convertir tareas ejecutables en tareas llamables
* NewsingLethreadExecutor: Genera un objeto Ejecutivo, que solo tiene un hilo que puede usarse para ejecutar tareas.
* NewCachedThreadPool (): genera un objeto Ejecutivo, que tiene un grupo de subprocesos.
* NewFixedThreadPool (int PoolSize): genera un objeto EjecutorService, que tiene un hilo de un grupo de tamaño de tamaño de tamaño.
* NewsingLethreadScheduledExecutor: genera un objeto ProgramedExecutorService, el tamaño del grupo de subprocesos de este objeto es 1. Si hay más de una tarea, las tareas se ejecutarán en secuencia.
* NewsCheduledThreadPool (int PoolSize): genera un objeto ProgramedExecutorService, el tamaño del grupo de subprocesos de este objeto es PoolSize.
*/
Ejecución de clase pública {
/**
* Este hilo genera una cadena
*/
Public static class mythread implementos runnables {
public void run () {
System.out.println ("Repetición de tareas" + System.CurrentTimemillis ());
intentar {
Thread.sleep (1000);
} capt (interruptedException e) {
System.out.println ("Tarea interrumpida".
+ System.CurrentTimemillis ());
}
}
}
/**
* El llamable finaliza otra tarea
*/
clase pública estática mycallable implementos llamables {
futuro privado futuro;
público mycallable (futuro futuro) {
this.future = futuro;
}
Call Public String () {
System.out.println ("para cancelar la tarea ..."
+ + System.CurrentTimemillis ());
this.future.cancel (verdadero);
devolver "Tarea cancelada!";
}
}
/**
* @param args
* @throws ExecutionException
* @throws interrumpedException
*/
Public static void main (string [] args) lanza interruptedException,
ExecutionException {
// Generar un objeto EjecutorService, que tiene un grupo de subprocesos, y el tamaño del grupo de subprocesos se ajustará según sea necesario.
// Después de que el hilo ejecuta la tarea, vuelve al grupo de subprocesos para la siguiente tarea que se utilizará.
EjecutorService CachedService = Ejecutors.NewCachedThreadPool ();
Future MyThreadFuture = Cachedservice.subMit (nuevo MyThread ());
Future myCallableFuture = Cachedservice.submit (nuevo mycallable (
mythreadfuture));
System.out.println (myCallableFuture.get ());
System.out.println ("-----------------");
// Convertir tareas ejecutables en tareas invocables
Callable myThreadCallable = Executors.Callable (new MyThread ());
Future MyThreadCallableFuture = Cachedservice.subMit (MyThreadCallable);
// Para tareas ejecutables, no se devuelve ningún valor después de convertirse en tareas invocables
System.out.println (myThreadCallableFuture.get ());
Cachedservice.shutdownnow ();
System.out.println ("-----------------");
// Generar un objeto EjecutorService, que tiene un grupo de hilos de tamaño de agrupación de tamaño.
// Si el número de tareas es mayor que el tamaño de la agrupación, las tareas se ejecutarán en una cola en secuencia
EjecutorService fijo fijo = ejecutors.newFixedThreadPool (2);
fixedservice.submit (new MyThread ());
fixedservice.submit (new MyThread ());
// Dado que el tamaño del grupo de subprocesos es 2, las tareas posteriores deben esperar a que las tareas anteriores se ejecuten antes de que puedan ejecutarse.
myThreadFuture = FixedService.SubMit (nuevo MyThread ());
myCallableFuture = FixedService.SubMit (nuevo myCallable (myThreadFuture));
System.out.println (myCallableFuture.get ());
fijoservice.shutdownnow ();
System.out.println ("-----------------");
// Generar un objeto ProgramedExecutorService, el tamaño del grupo de subprocesos de este objeto es el tamaño de la piscina.
// Si el número de tareas es mayor que el tamaño de la agrupación, la tarea esperará la ejecución en una cola
ProgramedExecutorService fijoscheduledservice = ejecutores
.NewScheduledThreadPool (2);
// crear una nueva tarea 1
MyThread Task1 = new MyThread ();
// Use el servicio de ejecución de tareas para ejecutar la Tarea 1 inmediatamente, y luego ejecute la Tarea 1 cada 2 segundos a partir de entonces.
myThreadFuture = FixedScheduledService.schedleatFixedRate (Tarea1, 0, 2,
TimeUnit.seconds);
// crear una nueva tarea 2
Mycallable tarea2 = new MyCallable (MyThreadFuture);
// Use el servicio de ejecución de tareas para esperar 5 segundos antes de ejecutar la tarea 2. Después de ejecutarla, la tarea 1 se cerrará.
myCallableFuture = FixedScheduledService.schedule (Tarea2, 5,
TimeUnit.seconds);
System.out.println (myCallableFuture.get ());
FixedScheduledService.shutdownnow ();
}
}