Resumo do método de implementação de multithreading em java

Três maneiras de implementar multi-threading em java

Em Java, existem três maneiras de implementar multi-threading. O primeiro método: herde a classe de encadeamento e substitua a função de execução. O segundo método: implemente a interface executável e reescreva a função de execução. O terceiro método: implemente a interface chamada e substitua a função de chamada. Este artigo explicará como esses três métodos podem ser implementados por meio de exemplos. Se você precisar, consulte -o.

(1) Herite a classe Thread e substitua a função de execução.

 Classe xx estende o thread {public void run () {thread.sleep (1000) // o thread dorme por 1000 milissegundos, o sono faz com que o thread entre no estado do bloco e libere recursos}}

Start Thread:

Object.start () // inicie o tópico, execute a função de execução

(2) Implementar a interface executável, o código é o seguinte

 classe Mythread implementa Runnable {private String Name; public mythread (nome da string) {super (); this.name = nome; } @Override public void run () {for (int i = 0; i <200; i ++) {system.out.println ("thread"+name+"--->"+i); }}} classe pública threadDemo {public static void main (string [] args) {mythread a = new mythread ("a"); Mythread b = novo mythread ("b"); Mito c = novo mythread ("c"); novo thread (a) .start (); novo thread (b) .start (); novo thread (c) .start (); }}

(3) Implementar a interface chamada e reescrever a função de chamada

Callable é uma interface semelhante ao Runnable. As classes que implementam a interface chamada e as classes que implementam o Runnable são tarefas que podem ser executadas por outros threads.

Existem várias diferenças entre chamadas e executáveis:

1. O método especificado pelo chamável é chamado (), enquanto o método especificado pelo runnable é executado ().
   
2. A tarefa chamada pode retornar o valor após a execução, enquanto a tarefa executável não pode retornar o valor.
   
3. O método Call () pode lançar exceções, enquanto o método run () não pode lançar exceções.
   
4. A execução da tarefa chamada pode obter um objeto futuro e o futuro representa o resultado de cálculos assíncronos. Ele fornece um método para verificar se o cálculo é concluído, para aguardar a conclusão do cálculo e recuperar os resultados do cálculo. Através do objeto futuro, você pode entender o status de execução da tarefa, cancelar a execução da tarefa e também obter os resultados da execução da tarefa
   

Exemplo de código chamável java:

 classe TaskWithResult implementa Callable <string> {private int id; public tarefaWithResult (int id) {this.id = id; } @Override public String Call () lança Exceção {return "Resultado de TaskWithResult" + ID; }} classe pública callableTest {public static void main (string [] args) lança interruptedException, ExecutionException {ExecutorService Exec = executores.newcachedThreadpool (); ArrayList <FUTTURA <String>> Resultados = new ArrayList <FUTTURA <String>> (); // Future é equivalente a um contêiner usado para armazenar os resultados da execução do executor para (int i = 0; i <10; i ++) {Results.add (Exec.submit (novo TaskWithResult (i))); } para (futuro <string> fs: resultados) {if (fs.isdone ()) {System.out.println (fs.get ()); } else {System.out.println ("O resultado futuro ainda não está completo"); }} exec.shutdown (); }}

Obrigado pela leitura, espero que isso possa ajudá -lo. Obrigado pelo seu apoio a este site!