O estado do tópico
Diagrama de status do tópico:
ilustrar:
Os tópicos incluem os 5 estados a seguir.
1. Novo Estado : Depois que o objeto Thread for criado, ele entra no novo estado. Por exemplo, Thread Thread = new Thread ().
2. Runnable: Também conhecido como "Estado executável". Depois que o objeto Thread for criado, outros threads chamam o método START () do objeto para iniciar o thread. Por exemplo, thread.start (). Um tópico em um estado pronto pode estar programado para executar pela CPU a qualquer momento.
3. Estado em execução: o encadeamento obtém permissões de CPU para execução. Deve -se notar que os threads só podem entrar no estado em execução do estado pronto.
4. Estado bloqueado: Estado bloqueado significa que o thread renuncia aos direitos de uso da CPU por algum motivo e para temporariamente a execução. Não é até o encadeamento entrar no estado pronto que ele tem a chance de ir ao estado de corrida. Existem três tipos de bloqueio:
(1) Esperando para bloquear - chamando o método Wait () Thread's Wait (), deixe o thread aguardar a conclusão de um determinado trabalho.
(2) Bloqueio sincronizado-um encadeamento falha ao adquirir trava de sincronização sincronizada (porque a trava é ocupada por outros threads), ele entrará em um estado de bloqueio sincronizado.
(3) Outro bloqueio-o thread entrará em um estado de bloqueio chamando Sleep () ou ingressar () do thread ou emitindo uma solicitação de E/S. Quando o Sleep () State se estendeu, a junção () esperou que o thread termine ou o tempo de tempo ou o processamento de E/S tenha sido concluído, o thread reinseriu para o estado pronto.
5. Estado morto: o thread terminou de executar ou sair do método run () devido a uma exceção e o thread termina seu ciclo de vida.
O conteúdo envolvido nesses 5 estados inclui a classe de objeto, encadeamento e palavras -chave sincronizadas. Aprenderemos esses conteúdos um por um nos capítulos seguintes.
Classe de objeto, define funções de sono/vigília como wait (), notify (), notifyAll (), etc.
A classe Thread define algumas funções de operação do encadeamento da coluna. Por exemplo, Sleep () Sleep Function, interrupt () Função de interrupção, getName () Get thread Name, etc.
Sincronizado é uma palavra -chave; É distinguido por blocos de código sincronizado e métodos sincronizados. A função de sincronizada é permitir que os threads adquiram o bloqueio de sincronização do objeto.
Quando introduzirmos wait (), notify () e outros métodos em detalhes posteriormente, analisaremos por que "wait (), notify () e outros métodos devem ser definidos na classe de objeto, não na classe de threads".
Duas maneiras de implementar multi-threading: Thread e Runnable
Runnable é uma interface que contém apenas um método Run (). Sua definição é a seguinte:
interface pública runnable {public abstrate void run ();} O papel do Runnable, implementa multi-threading. Podemos definir uma classe A para implementar a interface executável; Em seguida, crie um novo thread através do novo thread (novo A ()) e outros métodos.
Tópico é uma classe. O próprio Thread implementa a interface executável. Sua afirmação é a seguinte:
A classe pública thread implementa Runnable {}
O papel do thread é realizar multi-threading.
Similaridades e diferenças entre Thread e Runnable:
A semelhança entre thread e runnable: ambos são "métodos de implementação com vários threads".
As diferenças entre Thread e Runnable:
Thread é uma classe e o Runnable é uma interface; O Thread em si é uma classe que implementa a interface executável. Sabemos que "uma classe pode ter apenas uma classe pai, mas pode implementar várias interfaces", então o Runnable tem melhor escalabilidade.
Além disso, o Runnable também pode ser usado para "compartilhar recursos". Ou seja, vários threads são criados com base em um determinado objeto executável e compartilharão recursos no objeto Runnable.
Geralmente, é recomendável implementar multi-threading através do "Runnable"!
Exemplos multithreading para threads e runnable
1. Exemplo multithreading de thread
Abaixo, podemos entender melhor o thread e o Runnable por meio de exemplos e usar um exemplo on -line que é mais convincente. // ThreadTest.java Código fonte
classe mythread estende thread {private int ticket = 10; public void run () {for (int i = 0; i <20; i ++) {if (this.ticket> 0) {System.out.println (this.getName ()+"Tickets: ticket"+this.Ticket--); }}}}}}; public class ThreadTest {public static void main (string [] args) {// iniciar 3 threads t1, t2, t3; Cada tópico vende 10 ingressos! Mythread t1 = new mythread (); Mythread t2 = new mythread (); Mythread t3 = new mythread (); t1.start (); t2.start (); t3.start (); }} Resultados em execução:
Thread-0 Ticket Selling: ticket10Thread-1 Ticket Selling: ticket10Thread-2 Ticket Selling: ticket10Thread-1 Ticket Selling: ticket9Thread-0 Ticket Selling: ticket9Thread-1 Ticket Selling: ticket8Thread-2 Ticket Selling: ticket9Thread-1 Ticket Selling: ticket7Thread-0 Ticket Selling: ticket8Thread-1 Ticket Selling: ticket6Thread-2 Ticket Selling: ticket8Thread-1 Ticket Selling: ticket5Thread-0 Ticket Selling: ticket7Thread-1 Ticket Selling: ticket4Thread-2 Ticket Selling: ticket7Thread-1 Ticket Selling: ticket3Thread-0 Tickets: ticket6Thread-1 Tickets: ticket2Thread-2 Tickets: ticket6Thread-2 Tickets: ticket5Thread-2 Tickets: ticket4Thread-1 Tickets: ticket1Thread-0 Tickets: ticket5Thread-2 Tickets: ticket3Thread-0 Tickets: ticket4Thread-2 Tickets: ticket2Thread-0 Ingressos: Ticket3Thread-0 Ingressos: Ticket1Thread-0 Ingressos: Ticket2Thread-0 Ingressos: Ticket1Thread-0 Tickets: Ticket2Thread-0 Tickets: Ticket1
Resultados Descrição:
(1) Mythread herda do thread, que é um thread personalizado. Cada mythread vende 10 ingressos.
(2) A linha principal principal cria e inicia 3 threads infantis mithread. Cada fio infantil vende 10 ingressos.
2. Exemplo multithread de runnable
Em seguida, modificamos o programa acima. Implementar uma interface através do Runnable, implementando assim o multi-threading.
// runnabletest.java Código -fonte Mythread implementa Runnable {private int ticket = 10; public void run () {for (int i = 0; i <20; i ++) {if (this.ticket> 0) {System.out.println (thread.currentThread (). getName ()+"Ticket Selling: Ticket"+this.Ticket--); }}}}}; classe pública runnabletest {public static void main (string [] args) {mythread mt = new mythread (); // Inicie 3 threads T1, T2, T3 (eles compartilham um objeto executável), e esses 3 threads vendem um total de 10 ingressos! Thread t1 = novo thread (mt); Tópico T2 = novo thread (mt); Thread t3 = novo thread (mt); t1.start (); t2.start (); t3.start (); }} Resultados em execução:
Tópico-0 Ticket Saling: Ticket10Thread-2 Tickets Vendas: Ticket8Thread-1 Ticket Saling: Ticket9Thread-2 Ticket Saling: Ticket6Thread-0 Ticket Saling: Ticket7Thread-2 Ticket Saling: Ticket4Thread-1 Ticket3Thread Selling: Ticket5Thread-2 Ticket-2 Vendas: Ticket2Thread-0 Selling: Ticket3Thread-1 Selling: 2 Ticket-2
Resultados Descrição:
(1) ao contrário dos "Mythread herdos de threads acima"; Aqui o mythread implementa a interface do thread.
(2) O encadeamento principal principal cria e inicia 3 threads infantis, e esses três threads infantis são todos criados com base em "MT, objeto executável". O resultado da operação é que esses três fios infantis venderam um total de 10 bilhetes. Isso significa que eles compartilham a interface mythread.