Tópico de comparação de threads java, executável, chamável
O Java usa a classe Thread para representar threads, e todos os objetos de campo devem ser instâncias da classe Thread ou sua subclasse. A função de cada encadeamento é concluir uma determinada tarefa, que é realmente executar um fluxo de programa. O Java usa órgãos de execução do encadeamento para representar esse fluxo de programa.
1. Herde a classe de thread para criar thread
As etapas para iniciar o multithreading são as seguintes:
(1) Defina a subclasse da classe Thread e substitua o método run () da classe. O método do método do método do run () representa as tarefas que o thread de classe precisa concluir. Portanto, o método RUN () é chamado de órgão de execução do thread.
(2) Crie uma instância da subclasse do encadeamento, ou seja, crie um objeto Thread.
(3) Chame o método Star () do thread para iniciar o thread.
Os códigos relevantes são os seguintes:
/ *** herde a classe interna do thread para comprar ingressos, por exemplo*/ public class FirstThread estende o thread {private int i; Ticket privado int = 10; @Override public void run () {for (; i <20; i ++) {// Ao herdar Thread, use isso diretamente para obter o thread atual, getName () obtenha o nome do thread atual // log.d (tag, getName ()+""+i); if (this.ticket> 0) {log.e (tag, getName () + ", Ticket Selling: ticket =" + ticket--); }}}} private void starticketThread () {log.d (tag, "starticketThread"+thread.currentThread (). getName ()); FirstThread Thread1 = new FirstThread (); FirstThread Thread2 = new FirstThread (); FirstThread Thread3 = new FirstThread (); Thread1.start (); Thread2.start (); thread3.start (); // Abra 3 threads para comprar ingressos, cada tópico vendeu 10 ingressos e um total de 30 ingressos}Resultados em execução:
Você pode ver que as variáveis de voto inseridas por 3 threads não são contínuas. Nota: O ticket é uma propriedade de instância do FirstThread, não uma variável local, mas como o programa precisa criar um objeto FirstThread toda vez que cria um objeto Thread, todos os vários threads não compartilham os atributos da instância.
2. Implemente a interface executável para criar threads
Nota: Tópico de classe pública implementa Runnable
(1) Defina a classe de implementação da interface executável e substitua o método run () da interface. O método do método do método de execução () também é o corpo de execução do encadeamento da rosca.
(2) Crie uma instância da classe Runnable Instância. Esta instância é usada como um alvo de encadeamento para criar um objeto Thread. O objeto Thread é o objeto real.
Os códigos relevantes são os seguintes:
/ ** * Implemente a interface executável e crie uma classe de thread */ public classe SecondThread implementa runnable {private int i; Ticket privado int = 100; @Override public void run () {for (; i <20; i ++) {// Se a classe Thread implementa a interface executável // obtenha o thread atual, você pode usar apenas Thread.currentThread () para obter o nome do thread atual.d (tag, thread.currentthread (). GetName ()+""+i); if (this.ticket> 0) {log.e (tag, thread.currentThread (). getName () + ", venda de ingressos: ticket =" + ticket--); }}}} private void starticketThread2 () {log.d (tag, "starticketThread2,"+thread.currentThread (). getName ()); SecondThread SecondThread = new SecondThread (); // Crie um novo thread através do novo thread (Target, Name) New Thread (SecondThread, "Ticket Bunder 1"). Start (); novo thread (SecondThread, "Ticket Bunder 2"). Start (); novo thread (SecondThread, "Ticket Bunder 3"). Start (); // Embora 3 threads tenham sido abertos, apenas 100 ingressos foram comprados no total}Resultados em execução:
Você pode ver que as variáveis de voto inseridas por 3 threads são contínuas e vários threads podem compartilhar as propriedades da instância da classe Thread usando a interface executável. Isso ocorre porque, dessa maneira, o objeto executável criado pelo programa é apenas o alvo de um thread e vários threads podem compartilhar o mesmo alvo, para que vários threads possam compartilhar as propriedades da instância da mesma classe de encadeamento (que realmente deve ser a classe de destino do thread).
3. Crie tópicos usando chamadas e futuro
A partir do Java 5, o Java fornece uma interface chamada, que é uma versão aprimorada do Runnable. Callable fornece uma classe chamada () que pode ser usada como um corpo de execução de threads, mas o método Call () é mais poderoso.
(1) O método Call () pode ter um valor de retorno (2) o método Call () pode declarar uma exceção lançada
Portanto, podemos fornecer um objeto chamável como o destino do encadeamento, e o executor do thread é o método Call () do objeto chamável. Ao mesmo tempo, o Java 5 fornece a interface futura para representar o valor de retorno do método Call () na interface chamada e fornece uma classe de implementação do FutureTask. Esta classe de implementação implementa a interface futura e implementa a interface executável - um destino que pode ser usado como uma classe de encadeamento.
As etapas de inicialização são as seguintes:
(1) Crie uma classe de implementação da interface chamada e implemente o método Call (). O método Call () será usado como o corpo de execução do thread e o método Call () tem um valor de retorno.
(2) Crie uma instância da classe de implementação chamada e use a classe FutureTask para envolver o objeto chamável. O objeto FutureTask encapsula o valor de retorno do método Call ().
(3) Crie e inicie um novo thread usando o objeto FutureTask como alvo do objeto Thread.
(4) Ligue para o método get () do objeto FutureTask para obter o valor de retorno após a execução do thread infantil.
Os códigos relevantes são os seguintes:
/ *** Use o Callable para implementar a classe Thread*/ public class TercelThread implementa Callable <Integer> {private int ticket = 20; @Override public Integer Call () {for (int i = 0; i <10; i ++) {// Obtenha o thread atual, você pode usar apenas thread.currentThread () para obter o nome do thread atual // log.d (tag, thread.currentThread (). GetName ()+""+i); if (this.ticket> 0) {log.e (tag, thread.currentThread (). getName () + ", tickets: ticket =" + ticket--); }} Ticket Return; }} private void starCallableThRead () {terceirothread TercelThread = new ThirdThread (); FutureTask <Integer> Task = new FutureTask <Integer> (TercentThread); novo thread (tarefa, "Thread with Return Value"). Start (); tente {integer integer = task.get (); Log.d (tag, "starCallableThread, o valor de retorno do filho da criança ="+inteiro); } catch (interruptedException e) {e.printStackTrace (); } catch (ExecutionException e) {e.printStackTrace (); }}Resultados em execução:
NOTA: O método Call de Callable () permite que as declarações lançam exceções e permitam valores de retorno.
O programa finalmente chama o método get () do objeto FutureTask para retornar o valor de retorno do método Call (), fazendo com que o encadeamento principal seja bloqueado até que o método Call () termine e retorne.
4. Comparação de três maneiras
Crie multithreading ao herdar aula de threads
Desvantagens: A classe Thread foi herdada não pode ser herdada de outras classes pais.
Vantagens: simples de escrever
Crie multi-threading usando o método de herdar interfaces executáveis e chamáveis
Desvantagens: A programação é um pouco complicada. Se você precisar acessar o thread atual, você deve usar o thread.currentThread ()
Vantagens:
(1) Ele também pode herdar outras classes (2) vários threads podem compartilhar um objeto de destino, por isso é muito adequado para vários threads idênticos para lidar com o mesmo recurso, separando assim a CPU, o código e os dados para formar um modelo claro, que reflete melhor a idéia de classe orientada a objetos.
Obrigado pela leitura, espero que isso possa ajudá -lo. Obrigado pelo seu apoio a este site!