Recentemente, aprendi e estudei o uso do Java multi-threading ao fazer otimização de código e depois o resumi depois de ler as idéias dos novatos.
1. Herite a classe de threads para implementar a multi-threading
Embora o método que herde a classe Thread seja listado como um método de implementação com vários thread, o encadeamento é essencialmente uma instância da interface executável, que representa uma instância de um encadeamento, e a única maneira de iniciar um encadeamento é através do método de instância inicial () da classe Thread. O método start () é um método nativo que iniciará um novo thread e executará o método run (). Este método é muito simples de implementar multi-threading. Ao estender diretamente o thread através de sua própria classe e reescrever o método run (), você pode iniciar um novo thread e executar o método run () que você definir. Por exemplo:
public class mythread estende thread {public void run () {System.out.println ("mythread.run ()"); }} Inicie o tópico no lugar certo da seguinte forma:
Mythread mythread1 = new mythread (); Mythread mythread2 = new mythread (); mythread1.start (); mythread2.start ();
2. Implemente a interface executável para implementar a multi-threading
Se sua classe já estender outra classe, você não poderá estender o thread diretamente. No momento, você deve implementar uma interface executável, como segue:
public class Mythread estende o outro implementos runnable {public void run () {System.out.println ("mythread.run ()"); }} Para iniciar o Mythread, você precisa primeiro instanciar um thread e passar em sua própria instância de mythread:
Mythread mythread = new mythread (); Thread Thread = novo thread (mythread); thread.start ();
De fato, quando um parâmetro de destino executável é passado para o Thread, o método run () do thread chama Target.run (), consulte o código -fonte JDK:
public void run () {if (Target! = null) {Target.run (); }} 3. Use ExecororService, Callable e Future para obter multi-thread com resultados de retorno
Os objetos ExecutService, Callable e Future são realmente classes funcionais na estrutura do executor. Esta é uma explicação muito detalhada da estrutura. O thread que retorna o resultado é um novo recurso introduzido no JDK1.5. É realmente muito prático. Com esse recurso, não preciso ter muitos problemas para obter o valor de retorno e, mesmo que seja implementado, pode estar cheio de brechas.
As tarefas que podem retornar valores devem implementar a interface chamada e, da mesma forma, as tarefas que não retornam valores devem ter a interface executável. Depois de executar a tarefa chamada, você pode obter um objeto futuro. Ligue para o objeto, ligue para o objeto para retornar o objeto pela tarefa chamada. Combinado com a interface do pool de threads ExecorService, você pode perceber o lendário multi-threading com o resultado de retorno. Abaixo está um exemplo completo de teste com vários threads com resultados retornados. Se você o verificou no JDK1.5, poderá usá -lo diretamente. O código é o seguinte:
importar java.util.Concurrent.*; importar java.util.date; importar java.util.list; importar java.util.arraylist; / *** Thread with Return Value*/ @suppresswarnings ("desmarcado") Teste de classe pública {public static void main (string [] args) lança ExecutionException, interruptedException { System.out.println ("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- = Executores.NewfixedThEadPool (TaskSize); System.out.println (">>>" + f.get (). ToString ()); // Obtenha os resultados em execução de todas as tarefas simultâneas para (Future F: List) {// Obtenha o valor de retorno da tarefa do objeto futuro e anda -o para o console System.out.println (">>>" + f.get (). Tostring ()); } Data date2 = new Date (); System.out.println("----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- MyCallable (String Tasknum) {this.tasknum = Tasknum; System.out.println (">>>" Tasknum + "Terminação de tarefas"); Descrição do código:
No código acima, a classe Executores fornece uma série de métodos de fábrica para criar o pool de threads, e os pools de threads retornados implementam a interface ExecutService.
Public Static ExecorsService NewFixedThreadpool (int nthreads)
Cria um pool de threads com um número fixo de threads.
Public Static ExecorsService NewCachedThreadpool ()
Crie um pool de threads em cache, a chamada de execução reutiliza threads construídos anteriormente (se o thread estiver disponível). Se o thread existente não estiver disponível, crie um novo thread e adicione -o ao pool. Termine e remova as roscas do cache que não foram usadas por 60 segundos.
Public Static ExecorsService NewsingleThreadExecutor ()
Crie um executor de thread único.
Public Static ScheduledExecutorService NewscheduledThreadpool (int CorePoolSize)
Crie um pool de threads que suporta a execução de tarefas cronometradas e periódicas, que pode ser usada na maioria dos casos, em vez da classe do timer.
Executoreservice fornece o método submit (), passando um chamável, ou executável e retornando o futuro. Se o pool de threads de fundo do executor não tiver concluído o cálculo chamável, esta chamada retornará o método get () do objeto futuro, que será bloqueado até que o cálculo seja concluído.