Vá direto ao ponto
Nos círculos de TI, sempre que falamos sobre simultaneidade, estamos fadados a falar sobre uma série de threads rodando simultaneamente em um computador. Se houver vários processadores ou um processador multi-core neste computador, então ele está realmente "executando simultaneamente"; no entanto, se o computador tiver apenas um processador de núcleo único, então "execução simultânea" é apenas uma aparência;
Todos os sistemas operacionais modernos suportam a execução simultânea de tarefas. Você pode ouvir música e ler notícias online sem atrasar o primeiro e-mail. Podemos dizer que essa simultaneidade é uma simultaneidade em nível de processo. Dentro do processo, também posso perceber que existem muitas tarefas simultâneas. Chamamos tarefas simultâneas em execução em threads de um processo.
Outro conceito comum relacionado à simultaneidade é o paralelismo. Existem algumas diferenças e algumas conexões entre simultaneidade e paralelismo. Alguns programadores (Autor, transliterado como "programador") acreditam que a execução de um aplicativo com vários threads em um processador de núcleo único é simultânea, e você pode observar a execução do programador, além disso, quando seu programa é executado com vários threads, quando os threads são executados; em vários processadores ou processadores multi-core, eles são paralelos. Existem também alguns programadores que pensam que se os threads da aplicação não são executados em uma ordem predefinida, é simultaneidade para simplificar a solução do problema, um thread é usado, e esses threads são executados em uma determinada ordem, então; isso é paralelismo.
Este capítulo usará doze exemplos para demonstrar como usar a API Java7 para realizar algumas operações básicas de thread. Você poderá ver, em um programa Java, como criar e executar threads, como controlar a execução de threads, como manipular um grupo de threads como uma unidade, etc.
Nesta seção, aprenderemos como criar um thread em um programa Java e como executá-lo. Em um programa Java, tudo é um objeto, assim como os threads. Existem duas maneiras de criar tópicos:
1. Herde a classe Thread e substitua o método run();
2. Crie uma classe que implemente a interface Runnable, depois crie um objeto da classe Thread e, em seguida, passe a instância da classe que implementa a interface Runnable como parâmetro para a instância da classe Thread.
Nesta seção, usaremos o segundo método para criar dez threads e executá-los. Cada thread calcula e imprime o produto de dois inteiros dentro de dez.
saiba disso
Siga as etapas descritas abaixo para implementar este exemplo:
1. Crie uma classe chamada Calculator e implemente a interface Runnable. O código é o seguinte:
Copie o código do código da seguinte forma:
classe pública Calculadora implementa Runnable {
2. Declare um atributo inteiro privado denominado número e implemente o construtor desta classe para inicializar o atributo recém-declarado. O código é o seguinte:
Copie o código do código da seguinte forma:
número interno privado;
calculadora pública (número interno) {
este.número = número;
}
3. Implemente o método run(), que é o programa (instrução) que roda quando o thread que criamos é executado, portanto este método é usado para calcular a tabuada. O código específico é o seguinte:
Copie o código do código da seguinte forma:
@Substituir
execução void pública() {
for (int i = 0; i < 10; i++) {
System.out.printf("%s: %d * %d = %d/n",
Thread.currentThread().getName(),
número, eu, eu * número);
}
}
4. Agora é hora de implementar a classe principal do aplicativo de exemplo. Crie uma classe chamada Main e adicione o método main na classe. O código é o seguinte:
Copie o código do código da seguinte forma:
classe pública Principal {
public static void main(String[] args) {
5. Dentro do método main(), crie um loop for que percorre dez vezes. No corpo do loop, crie uma calculadora de objeto da classe Calculator, crie um thread de objeto da classe Thread e passe a calculadora como parâmetro do. construtor para a instrução de inicialização. Finalmente, chame o método start() do objeto thread. O código é o seguinte:
Copie o código do código da seguinte forma:
for (int i = 0; i < 10; i++) {
Calculadora calculadora = nova Calculadora (i);
Thread thread = new Thread(calculadora);
thread.start();
}
6. Execute este programa para ver como diferentes threads são executados simultaneamente.
sabe por que
A seguir está uma saída impressa no console ao executar o programa. Podemos ver que todos os threads que criamos estão sendo executados simultaneamente.
Copie o código do código da seguinte forma:
Tópico 3: 3 * 5 = 15
Tópico-0: 0 * 2 = 0
Tópico 3: 3 * 6 = 18
Tópico 1: 1 * 6 = 6
Tópico 1: 1 * 7 = 7
Tópico 3: 3 * 7 = 21
Tópico 3: 3 * 8 = 24
Tópico-0: 0 * 3 = 0
Tópico-0: 0 * 4 = 0
Tópico 3: 3 * 9 = 27
Tópico 1: 1 * 8 = 8
Todos os programas Java executam pelo menos um thread. Quando executamos um programa Java, a Java Virtual Machine (doravante denominada JVM) executará um thread e chamará o programa que contém o método main().
Quando o método start() do objeto Thread é chamado, outro thread é criado. Quantas vezes o método start() é chamado, quantos threads serão criados.
Quando todos os threads tiverem concluído a execução, o programa Java será encerrado. (A menos que em circunstâncias especiais, todos os threads não-daemon sejam executados.) Quando o thread inicial (como o thread que executa o método main()) termina, os threads restantes continuarão a ser executados até que a tarefa de computação seja concluída. Quando um dos threads chama System.exit(), solicitando que a JVM encerre o programa, todos os threads encerram sua execução.
Quando o método run() do objeto Thread for chamado, o thread não será criado da mesma forma, quando o método run() da classe que implementa a interface Runnable for chamado, o thread não será criado. Um thread é criado somente quando o método start() do objeto Thread é chamado.
sem fim
Conforme mencionado no início desta seção, existe outra maneira de criar um thread: herdar a classe Thread e substituir o método run(). Dessa forma, você pode criar um objeto da subclasse Thread e então chamar start(). método do objeto. Criar thread.
Copie o código do código da seguinte forma:
Como estava me preparando para a entrevista, encontrei um monte de informações sobre multi-threading Java, incluindo este "Java 7 Concurrency Cookbook". As explicações são muito simples e fáceis de entender. É muito adequado para amigos que não sabem. muito sobre multi-threading, mas quero aprender seriamente. Depois de pesquisar, não consegui encontrar a versão chinesa, então decidi fazer eu mesmo comida e roupas suficientes. Portanto, planejamos publicar uma tradução não oficial, e o título é provisoriamente intitulado "Coleção de exemplos de simultaneidade Java7".
Usar doutrina
Este artigo foi traduzido do "Java 7 Concurrency Cookbook" (D Gua Ge o roubou como "Java7 Concurrency Sample Collection") e é usado apenas como material de aprendizagem. Não pode ser utilizado para quaisquer fins comerciais sem autorização.
Pequeno sucesso
O livro original não possui o código completo, o que não é conveniente para visualização. Portanto, o irmão D Gua adicionou uma seção para mostrar a versão completa do código mostrado nesta seção.
O código completo da classe Calculadora é o seguinte:
pacote com.diguage.books.concurrencycookbook.chapter1.recipe1;
/**
* Data: 13/09/2013
* Horário: 21h42
*/
classe pública Calculadora implementa Runnable {
número interno privado;
calculadora pública (número interno) {
este.número = número;
}
@Substituir
execução void pública() {
for (int i = 0; i < 10; i++) {
System.out.printf("%s: %d * %d = %d/n",
Thread.currentThread().getName(),
número, eu, eu * número);
}
}
}
O código completo da classe principal
Copie o código do código da seguinte forma:
pacote com.diguage.books.concurrencycookbook.chapter1.recipe1;
/**
* Data: 13/09/2013
* Horário: 19h46
*/
classe pública Principal {
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
Calculadora calculadora = nova Calculadora (i);
Thread thread = new Thread(calculadora);
thread.start();
}
}
}