1. O conceito de encadeamento: encadeamento refere -se ao fluxo de execução de uma tarefa do começo ao fim. O thread fornece um mecanismo para executar tarefas. Para Java, vários threads podem ser executados simultaneamente em um programa, e esses threads podem ser executados simultaneamente em um sistema multiprocessador. Quando o programa é executado como um aplicativo, o intérprete Java inicia um thread para o método Main ().
2. Paralelo e concorrência:
(1) Concorrência: em um sistema de processador único, vários threads compartilham o tempo da CPU e o sistema operacional é responsável pela programação e alocação de recursos para eles.
(2) Paralelismo: em um sistema multiprocessador, vários processadores podem executar vários threads ao mesmo tempo. Esses tópicos podem ser executados simultaneamente ao mesmo tempo. Ao contrário da simultaneidade, apenas vários threads podem compartilhar o tempo da CPU e apenas um thread pode ser executado ao mesmo tempo.
3. Criação de threads:
(1) Conceito básico: cada tarefa em Java é um objeto executável. Para criar uma tarefa, a classe de tarefas deve primeiro ser definida e a classe de tarefas deve implementar a interface executável. E threads são essencialmente objetos que são convenientes para a execução de tarefas. O processo de execução de um encadeamento é a execução do método run () em uma classe de tarefas até o final.
(2) Crie threads através da interface executável:
um. Defina uma classe de tarefa para implementar a interface executável, implemente o método run () na interface executável (o método run () informa ao thread do sistema como executar) e defina código de tarefa específico ou lógica de processamento no método run ().
b. Depois de definir a classe de tarefas, crie um objeto de tarefa para a classe de tarefas.
c. A tarefa deve ser executada em um thread, criar um objeto da classe de piso e passar no objeto da classe de tarefas criado anteriormente que implementa a interface executável para o construtor da classe de piso como um parâmetro.
d. Ligue para o método START () do objeto da classe da banda e inicie um thread. Isso faz com que o método run () da tarefa seja executado. Quando o método run () é executado, o thread será encerrado.
Exemplo Código:
pacote com.muzet.mutithread; // Cada tarefa é uma instância da interface executável. A tarefa é um objeto executável e o thread é um objeto que facilita a execução da tarefa. Você deve criar uma classe de tarefa e substituir o método de execução para definir a tarefa public class ThreadDemo1 implementa Runnable {private int contingdown = 10; @Override // Reescreva o método de execução e defina a tarefa public void run () {while (contagemdown--> 0) {System.out.println ("$" + Thread.currentThread (). GetName () + "(" + contagemdown + ")); }} // Chamando o método Iniciar iniciará um thread, fazendo com que o método de execução na tarefa seja chamado. Depois que o método de execução é executado, o thread termina public estático void main (string [] args) {runnable demo1 = new ThreadDemo1 (); Thread Thread1 = novo thread (Demo1); Thread Thread2 = novo thread (Demo1); Thread1.start (); Thread2.start (); System.out.println ("Rocket Launch Countdown:"); }}Resultados em execução do programa:
Rocket Launch Countdown: $ Thread-0 (9) $ Thread-0 (8) $ Thread-0 (7) $ Thread-0 (6) $ Thread-0 (5) $ Thread-0 (4) $ Thread-0 (3) $ Thread-0 (2) $ Thread-0 (1) $ Thread-0 (0)
Execute dois objetos de tarefa ao mesmo tempo:
public static void main (string [] args) {runnable demo1 = new ThreadDemo1 (); Runnable Demo2 = new ThreadDemo1 (); Thread Thread1 = novo thread (Demo1); Thread Thread2 = novo thread (Demo2); Thread1.start (); Thread2.start (); System.out.println ("Rocket Launch Countdown:"); }Resultados em execução:
Rocket Launch Countdown: $ Thread-0 (9) $ Thread-0 (8) $ Thread-0 (7) $ Thread-0 (6) $ Thread-1 (9) $ Thread-0 (5) $ Thread-1 (8) $ Thread-0 (4) $ Thread-1 (7) $ Thread-0 (3) $ Thread-1 (6) $ thread-1 (5) $ thread-0 (2) $ thread-1 (4) $ thread-1 (3) $ thread-1 (2) $ thread-1 (1) $ thread-1 (0) $ thread-0 (1) $ thread-0 (0)
(3) herdar a classe Thread para criar um thread:
um. Primeiro, crie uma classe de tarefas estende a classe Thread. Como a classe Thread implementa a interface executável, a classe de tarefas personalizada também implementa o método Runnable Interface e Rerun (), que define código de tarefa específico ou lógica de processamento.
b. Crie um objeto de classe de tarefa, que pode usar o Thread ou Runnable como um tipo de variável personalizado.
c. Ligue para o método start () do objeto personalizado e inicie um thread.
Código de exemplo:
pacote com.muzet.mutithread; // Cada tarefa é uma instância da interface executável. A tarefa é um objeto executável e o thread pode executar o objeto. A classe de tarefas deve ser criada e o método de execução deve ser substituído para definir a classe Public Class ExtendFromThread estende o thread {private int contingdown = 10; @Override // Reescreva o método Run e defina a tarefa public void run () {while (contagemdown--> 0) {System.out.println ("$" + this.getName () + "(" + contagemdown + ")); }} // Chamando o método Iniciar iniciará um thread, fazendo com que o método de execução na tarefa seja chamado. Depois que o método de execução é executado, o thread termina public static void main (string [] args) {extendFromThread Thread1 = new extendFromThread (); EstendFromThRead Thread2 = new ExtendFromThread (); Thread1.start (); Thread2.start (); System.out.println ("Rocket Launch Countdown:"); }}Resultados em execução:
Rocket Launch Countdown: $ Thread-0 (9) $ Thread-0 (8) $ Thread-0 (7) $ Thread-0 (6) $ Thread-0 (5) $ Thread-0 (4) $ Thread-0 (3) $ Thread-0 (2) $ Thread-0 (1) $ Thread-0 (0) $ Thread-1 (9) $ thread-1 (8) $ thread-1 (7) $ thread-1 (6) $ thread-1 (5) $ thread-1 (4) $ thread-1 (3) $ thread-1 (2) $ thread-1 (1) $ thread-1 (0)
Um thread aguarda que outro thread termine antes de executar: Ao executar a tarefa Printnum, ao imprimir o número 50, ele se volta para executar a tarefa de imprimir o caractere C e só continua a executar a tarefa de imprimir o número após a execução do thread4.
pacote com.muzeet.testThread; public class PrintNum implementa Runnable {private int lastNum; public printnum (int n) {lastNum = n; } @Override public void run () {// TODO Method Auto-Gerated Stub Thread4 = new Thread (new PrintChar ('C', 40)); thread4.start (); tente {for (int i = 1; i <= dinnum; i ++) {System.out.println (""+i); if (i == 50) {thread4.join (); }}} catch (interruptEdException e) {// TODO BLOCO DE CAPAÇÃO AUTOMENTADO E.PRINTSTACKTRACE (); }}}4. Comparação dos dois métodos (reimpresso)
Primeiro, analisamos os resultados da saída dos dois métodos. Também criamos dois threads. Por que os resultados são diferentes?
Usando a interface executável para criar threads, você pode compartilhar o mesmo objeto de destino (TreadDemo1TT = newtreadDemo1 ();), implementando vários threads idênticos para processar o mesmo recurso. Quando o primeiro thread concluir a tarefa, a contagem regressiva já é 0, portanto o segundo thread não será lançado. Herrando o método de criar threads por threads, dois objetos de classe de tarefas são criados, com suas respectivas variáveis de membros, e elas não interferem entre si.
Em seguida, olhe para uma explicação do JDK:
A interface executável deve ser implementada por classes que pretendem executar suas instâncias através de um determinado thread. A classe deve definir um método sem parâmetros chamado RUN.
O objetivo de projetar essa interface é fornecer um protocolo público para objetos que desejam executar o código quando ativos. Por exemplo, a classe Thread implementa a execução. A ativação significa que um tópico foi iniciado e ainda não parou.
Além disso, o Runnable fornece um método de ativação para classes que não são subclasses de encadeamento. Ao instantar uma instância do thread e se considerar o destino em execução, você pode executar uma classe que implementa o Runnable. Na maioria dos casos, se você deseja substituir o método run () e não substituir outros métodos de encadeamento, use a interface executável. Isso é importante porque, a menos que o programador pretenda modificar ou aprimorar o comportamento básico de uma classe, uma subclasse não deve ser criada para essa classe. (Recomenda -se usar a criação de uma classe de tarefas e a implementação da interface executável em vez de herdar a classe Thread)
Adote a herança da classe de threads:
(1) Vantagens: Fácil de escrever. Se você precisar acessar o thread atual, não precisará usar o método Thread.currentThread (). Você pode obter o thread atual diretamente usando isso.
(2) Desvantagens: Como a classe Thread herdou a classe Thread, não pode herdar outras classes pais.
Usando o método de interface executável:
(1) Vantagens: as classes de threads implementam apenas a interface executável e também podem herdar outras classes. Dessa maneira, vários threads podem compartilhar o mesmo objeto de destino, por isso é muito adequado para vários threads idênticos para lidar com o mesmo recurso, para que o código e os dados da CPU possam ser separados para formar um modelo claro, que reflete melhor a idéia orientada a objetos.
(2) Desvantagens: A programação é um pouco complicada. Se você precisar acessar o thread atual, use o método Thread.CurrentThread ().
Resumir
O exposto acima é tudo sobre as duas maneiras de criar threads nos exemplos Java Multithreading e Code Comparative. Espero que seja útil para todos. Se houver alguma falha, deixe uma mensagem para apontá -la. Obrigado amigos pelo seu apoio para este site!