A cópia do código é a seguinte:
pacote com.yao;
importar java.util.Concurrent.Callable;
importar java.util.concurrent.executionException;
importar java.util.concurrent.executorService;
importar java.util.concurrent.executores;
importar java.util.concurrent.future;
importar java.util.concurrent.scheduledExecutorService;
importar java.util.Concurrent.TimeUnit;
/**
* Nova arquitetura de execução de tarefas.
* Antes do Java 5.0, uma tarefa foi iniciada chamando o método start () da classe Thread.
* O envio e a execução da tarefa são realizadas simultaneamente.
* Ou controlar o número de threads executados simultaneamente requer código adicional para concluir.
* 5.0 Fornece uma nova arquitetura de execução de tarefas que permite agendar e controlar facilmente a execução de tarefas.
* E um pool de threads semelhante a um pool de conexão de banco de dados pode ser estabelecido para executar tarefas.
* Essa arquitetura consiste principalmente em três interfaces e suas classes específicas correspondentes.
*Essas três interfaces são executores, executorService e ScheduleDexecutorService.
* (1) Interface do executor: é usado para executar tarefas executáveis, ele define apenas um método:
* Execute (Runnable Command): Executar tarefas de tipo runable
* (2) ExecutorService: herda o método do executor e fornece serviços para executar tarefas chamáveis e abortar a execução da tarefa.
* Os principais métodos de sua definição são:
* Enviar (tarefa): pode ser usado para enviar tarefas chamáveis ou executáveis e retornar o futuro objeto que representa esta tarefa
* InvoKeall (Coleção de tarefas): coleta de tarefas em lote e retorne uma coleção de objetos futuros que representam essas tarefas.
* Shutdown (): Feche o serviço após concluir a tarefa enviada e não aceita mais novas tarefas.
* ShutdownNow (): interrompe todas as tarefas de execução e fecha o serviço.
* ISTERMERTINA (): teste se todas as tarefas foram executadas.
* isshutdown (): teste se o ExecorService foi fechado
* (3) ScheduledExecutorService: herda o ExecorService, fornecendo a função das tarefas de agendamento de acordo com o tempo,
* Cronograma (tarefa, initDelay): agende a tarefa chamada ou execução enviada a ser executada após o tempo especificado pelo InitDElay.
* scheduleAtFixedRate (): agende a tarefa executável enviada a ser executada repetidamente no intervalo especificado.
* schedulewithfixedDelay (): agende a tarefa executável enviada a ser executada repetidamente após cada execução, aguarde o tempo especificado por atraso.
*
* Obtenha vários objetos de serviço através da classe Executores.
* Callable (Runnable Task): converter tarefas executáveis em tarefas chamáveis
* NewsingLethReadExecutor: gera um objeto ExecorService, que possui apenas um thread que pode ser usado para executar tarefas.
* NewCachedThreadpool (): gera um objeto ExecorService, que possui um pool de threads.
* NewfixedThreadpool (int poolsize): gera um objeto ExecorsService, que possui um pool de threads de tamanho de tamanho.
* NewsingLethreadScheduledExecutor: gera um objeto ScheduleDexecutorService, o tamanho do pool de threads desse objeto é 1. Se houver mais de uma tarefa, as tarefas serão executadas em sequência.
* NewscheduledThreadpool (int poolsize): gera um objeto ScheduleDexecutorService, o tamanho do pool de threads desse objeto é o tamanho do pool.
*/
classe pública Executsearch {
/**
* Este thread gera uma string
*/
Classe estática pública Mythread implementa Runnable {
public void run () {
System.out.println ("Repetição de tarefas." + System.CurrentTimemillis ());
tentar {
Thread.sleep (1000);
} catch (interruptedException e) {
System.out.println ("Tarefa interrompida".
+ System.currenttimemillis ());
}
}
}
/**
* O chamável termina outra tarefa
*/
Classe estática pública implementos microfones chamáveis {
futuro privado;
public MyCallable (futuro futuro) {
this.future = futuro;
}
public String Call () {
System.out.println ("Para cancelar a tarefa ..."
+ + System.currenttimemillis ());
this.future.cancel (true);
retornar "Tarefa cancelada!";
}
}
/**
* @param args
* @Throws ExecutionException
* @THOWS INTERRUPEDEXCECTIMENTO
*/
public static void main (string [] args) lança interruptedException,
ExecutionException {
// Gere um objeto ExecorsService, que possui um pool de threads, e o tamanho do pool de threads será ajustado conforme necessário.
// Depois que o thread executa a tarefa, ele retorna ao pool de threads para que a próxima tarefa seja usada.
ExecutorService cachedservice = executores.newcachedthreadpool ();
Futuro mythreadfuture = cachedservice.submit (new mythread ());
Futuro myCallablefuture = cachedservice.submit (novo myCallable (
mythreadfuture));
System.out.println (myCallableFuture.get ());
System.out.println ("---------------");
// converte tarefas executáveis em tarefas chamáveis
Callable mythreadCallable = executores.callable (new mythread ());
Futuro mythreadCallablefuture = cachedservice.submit (mythreadCallable);
// Para tarefas executáveis, nenhum valor é retornado após ser convertido em tarefas chamáveis
System.out.println (mythreadCallablefuture.get ());
cachedservice.shutdownNow ();
System.out.println ("---------------");
// Gere um objeto ExecorsService, que possui um pool de threads de tamanho de tamanho.
// Se o número de tarefas for maior que o PoolSize, as tarefas serão executadas em uma fila em sequência
ExecutorService fIllService = executores.newfixedThreadpool (2);
FILLSERVICE.SUBMIT (new Mythread ());
FILLSERVICE.SUBMIT (new Mythread ());
// Como o tamanho do pool de threads é 2, as tarefas subsequentes devem aguardar a execução das tarefas anteriores antes de serem executadas.
mythreadfuture = fibrErService.submit (new mythread ());
myCallableFuture = fIllservice.submit (novo myCallable (mythreadfuture));
System.out.println (myCallableFuture.get ());
fIllService.shutdownNow ();
System.out.println ("---------------");
// Gere um objeto ScheduledExecutorService, o tamanho do pool de threads desse objeto é PoolSize.
// Se o número de tarefas for maior que o PoolSize, a tarefa aguardará a execução em uma fila
SGOUNDEDEXECONCONDORSERVICE
.NewscheduledThreadpool (2);
// Crie nova tarefa 1
Mythread tarefa1 = new mythread ();
// Use o serviço de execução de tarefas para executar a tarefa 1 imediatamente e, em seguida, execute a tarefa 1 a cada 2 segundos depois.
mythreadfuture = fibretScheduledservice.SCHEDULEATFIXEDRATE (Task1, 0, 2,
Timeunit.Segunds);
// Crie nova tarefa 2
MyCallable Task2 = novo MyCallable (mythreadfuture);
// Use o serviço de execução de tarefas para aguardar 5 segundos antes de executar a Tarefa 2. Após executá -lo, a Tarefa 1 será fechada.
MyCallableFuture = FILLSCHEDULEDSERVICE.SCHEDule (Task2, 5,
Timeunit.Seconds);
System.out.println (myCallableFuture.get ());
FILLSCHEDULEDSERVICE.SHUTDOWNNOW ();
}
}