Menu

Multithreading em Java - Tutorial com exemplos

multithreading java tutorial with examples

Experimente Nosso Instrumento Para Eliminar Problemas

Este tutorial explica tudo sobre multithreading em Java, implementação de simultaneidade, o ciclo de vida de um thread, exemplo de classe de thread, thread usando interface executável:

A simultaneidade no mundo da computação é a capacidade de um sistema (seja aplicativo, computador ou linguagem de programação) de executar várias instâncias de um programa ou aplicativo em paralelo.

Ao executar instâncias ou programas simultaneamente, garantimos alto rendimento e desempenho superior, pois podemos utilizar os recursos inexplorados, como hardware do sistema operacional, etc. Por exemplo, se um sistema tiver várias CPUs, o aplicativo pode utilizar essas CPUs de forma eficaz e aumentar o rendimento.

=> Visite aqui a série exclusiva de tutoriais de treinamento em Java.

Multithreading em Java

O que você aprenderá:

O que é multithreading em Java

Em Java, os threads podem ser vistos como a espinha dorsal da simultaneidade. Um thread é uma unidade executável leve que acessa recursos compartilhados, bem como sua própria pilha de chamadas.

Um aplicativo Java é um processo e, dentro desse aplicativo, podemos ter vários threads para obter simultaneidade.

Sabemos que um aplicativo em execução no sistema pode ter várias instâncias e geralmente são chamadas de aplicativos multi-doc. Essas instâncias de aplicativo são chamadas de processos. Cada um desses processos é atribuído a uma unidade de execução conhecida como thread.

Dependendo do sistema operacional e dos requisitos do aplicativo, o processo pode ser atribuído a um único thread ou a vários threads. Quando o processo do aplicativo é atribuído a vários threads, precisamos executar esses vários threads simultaneamente.

' Esta técnica de execução ou execução de vários threads simultaneamente ou simultaneamente é conhecida como multithreading . '

Multithreading significa simplesmente que temos mais de um thread em execução no mesmo aplicativo.

A linguagem de programação Java possui suporte integrado para multithreading.

multithreading

O multithreading é descrito no diagrama acima. Conforme mostrado, existem vários threads em execução simultaneamente dentro de um aplicativo.

Por exemplo, um aplicativo de desktop que fornece funcionalidades como edição, impressão, etc. é um aplicativo multithread. Neste aplicativo, como a impressão é um processo em segundo plano, podemos realizar a edição e a impressão de documentos simultaneamente, atribuindo essas funções a dois threads diferentes.

Os threads em aplicativos multithread são executados paralelamente entre si de maneira simultânea. Portanto, o multithreading também faz parte da simultaneidade em Java. Observe que, embora haja vários threads, eles compartilham a área de memória, economizando memória. Além disso, os threads podem alternar facilmente os contextos em nenhum momento.

O multithreading é útil principalmente porque fornece execução simultânea de duas ou mais partes de um aplicativo. Isso permite que o aplicativo utilize o tempo da CPU ao máximo e o tempo ocioso seja mínimo.

A seguir estão alguns dos termos que devemos saber em relação ao ambiente de multithreading, pois são usados ​​com frequência.

Multitarefa: Em multitarefa, mais de uma tarefa é executada ao mesmo tempo.

Multithreading: Multithreading, como já foi mencionado, é um processo de execução de vários threads simultaneamente.

como jogar servidor privado de world of warcraft

Multiprocessamento: No multiprocessamento, mais de um processo é executado simultaneamente. Semelhante à multitarefa, mas aqui mais de uma CPU está envolvida.

Processamento paralelo: O processamento paralelo é uma técnica em que várias CPUs trabalham simultaneamente em um sistema de computador.

Tendo discutido o multithreading, surge a questão de por que precisamos do multithreading?

Benefícios do multithreading

O multithreading tem vários benefícios que auxiliam na programação eficiente.

Os pontos abaixo deixarão isso claro.

# 1) Utilização eficiente de sistemas de CPU única

Quando há apenas uma CPU no sistema, com um único thread, o tempo da CPU é perdido. Quando o thread está ocupado usando outros recursos como IO, a CPU fica ociosa. Podemos melhorar isso e utilizar melhor a CPU por meio de aplicativos multithread.

Usando multithreading, se um thread é feito com CPU, então o outro thread pode utilizá-lo. Com vários threads, o tempo ocioso da CPU será bastante reduzido.

# 2) Utilização eficiente de vários sistemas de CPU

Assim como as CPUs individuais, mesmo com sistemas com várias CPUs, os aplicativos multithread podem utilizar várias CPUs com eficiência.

# 3) Experiência do usuário aprimorada com relação à capacidade de resposta e justiça

A capacidade de resposta do sistema melhora com aplicativos multithread. Não experimentamos o ‘GUI pendurado’ quando temos vários threads realizando várias tarefas no aplicativo e os usuários não precisam esperar muito tempo para obter uma resposta para suas solicitações.

Da mesma forma, os usuários são devidamente serviços em sistemas multithread.

Como implementar simultaneidade em Java

A primeira classe com a qual podemos implementar simultaneidade em Java é java.lang.Thread aula. Esta classe Thread forma a base da simultaneidade em Java.

Nos tambem temos java.lang.Runnable interface que pode ser implementada por uma classe Java para abstrair o comportamento do encadeamento. Para o desenvolvimento de aplicativos avançados, podemos fazer uso do java.util.concurrent pacote disponível desde Java 1.5.

Mais adiante, discutiremos a simultaneidade em Java em detalhes. Vamos discutir e entender o conceito de threads em Java neste tutorial. Em nossos tutoriais subsequentes sobre multithreading, exploraremos vários conceitos de multithreading e simultaneidade.

O que é um thread em Java

Um único thread pode ser definido como a menor e mais leve unidade de processamento. Em Java, threads são usados ​​em programas que usam a classe ‘Thread’.

Threads Java são de dois tipos:

Tipos de Thread em Java

# 1) Tópico do usuário: thread do usuário é criado quando o aplicativo é iniciado pela primeira vez. Então podemos criar tantos usuários e threads daemon.

# 2) Thread do Daemon: threads daemon são usados ​​principalmente em segundo plano e para tarefas como limpar o aplicativo, etc.

Threads reduzem o custo de manutenção do aplicativo. Também reduz a sobrecarga do aplicativo.

Um exemplo de thread único é mostrado abaixo:

public class Main{ public static void main (String () args){ System.out.println('This is a thread'); } }

O programa acima exibirá “Este é um encadeamento” como quando o aplicativo inicia um encadeamento do usuário é criado. No programa acima, a função principal é o ponto de partida da aplicação e cria um thread do usuário.

O ciclo de vida de um fio

O diagrama a seguir descreve o ciclo de vida de um encadeamento em Java.

Ciclo de vida do thread em Java

Conforme mostrado no diagrama acima, um thread em Java tem os seguintes estados:

# 1) Novo: Inicialmente, o encadeamento recém-criado da classe de encadeamento tem um estado ‘novo’. Ainda não foi iniciado. Este tópico também é chamado ‘Linha nascida’ .

# 2) Executável: Nesse estado, a instância de um thread é chamada usando o método 'começar' .

# 3) Executando: O método de início da instância do thread é invocado e o thread começa a execução. Este é o estado de execução. Principalmente o planejador programa e gerencia os threads.

# 4) Bloqueado: Existem vários threads em um aplicativo. Esses threads têm que esperar por outro, pois sua execução deve ser sincronizada.

# 5) Encerrado: Uma vez que o processo de execução do thread é concluído, o thread é encerrado ou sua execução é interrompida.

Portanto, um thread é primeiro criado, depois agendado e, posteriormente, o planejador executa o thread. Enquanto o thread em execução pode ser bloqueado ou suspenso por alguma outra atividade. Em seguida, ele é retomado e enquanto o processamento é concluído, o thread é executado.

Prioridades de discussão

Uma prioridade de encadeamento decide como um encadeamento deve ser tratado em relação aos outros encadeamentos em um aplicativo. Uma prioridade de thread é um número inteiro.

Listados abaixo estão alguns pontos a serem lembrados sobre as prioridades do tópico:

  • As prioridades de thread são números inteiros.
  • Usando a prioridade do thread, podemos decidir quando devemos alternar de um thread em estado de execução para outro. Este é o processo de troca de contexto em que trocamos os contextos das threads.
  • Sempre que um thread pode liberar voluntariamente seu controle sobre a CPU. Então, o tópico com a prioridade mais alta pode assumir.
  • Da mesma forma, um thread de prioridade mais alta pode antecipar qualquer outro thread com prioridade mais baixa.
  • A classe Thread fornece um método setPriority () que é usado para definir a prioridade do thread.
  • Também podemos usar constantes MIN_PRIORITY, MAX_PRIORITY ou NORM_PRIORITY no lugar de inteiros.

Criar um Tópico

Podemos criar uma discussão usando uma das seguintes maneiras:

  1. Estendendo a classe Java ‘Thread’.
  2. Implementando ‘Executável’.

Estendendo a classe Java ‘Thread’

A classe ‘Thread’ contém os construtores e métodos que nos permitem criar e realizar operações em um objeto thread. Internamente, a classe Thread implementa a interface Runnable e também estende a classe Object.

A tabela a seguir fornece um resumo de vários construtores e métodos de uma classe Thread ().

Construtor/ProtótipoDescrição
dorme public void sleep (longos milissegundos)A execução do thread atual é interrompida por milissegundos especificados.
Construtor Thread () Fio()Construtor padrão para criar um objeto Thread.
Tópico (nome da string)Construtor para criar um objeto Thread com o nome especificado.
Thread (executável r)Crie uma instância de Thread com o objeto de interface Runnable especificado.
Thread (r executável, nome da string)Cria uma instância de Thread com o objeto de interface Runnable especificado e o nome dado
corre public void run ()O método Run executa a ação para um thread. Invoca o tópico.
começar public void start ()Usado para iniciar a execução do thread. Internamente, a JVM chama o método run () neste encadeamento.
Junte-se public void join ()Espere o fio morrer
public void join (longos milissegundos)Aguarde os milissegundos especificados para o encadeamento morrer.
getPriority public int getPriority ()Retorne a prioridade do tópico
setPriority public int setPriority (prioridade interna)Altere a prioridade do thread para a prioridade especificada
getName public String getName ()retorna o nome do tópico.
nome do conjunto public void setName (nome da string)Defina o nome do thread para a string especificada
currentThread public Thread currentThread ()Retorna a referência do segmento que está ativo no momento
getId public int getId ()ID do tópico de retorno
getState () public Thread.State getState ()Retorna o estado atual do tópico
Está vivo public boolean isAlive ()Verifique se o thread está ativo e retorne verdadeiro se sim.
produzem public void yield ()Pausa temporariamente o thread atual e permite que outros threads sejam executados.
isDaemon public boolean isDaemon ()Verifique se o thread é um thread daemon; retorna verdadeiro se sim.
setDaemon public void setDaemon (boolean b)Defina o thread como um thread daemon if b = true; senão definido como thread do usuário.
interromper public void interrupt ()Interrompe o tópico atual.
é interrompido public boolean isInterrupted ()Verifique se a discussão foi interrompida.
interrompido public static boolean interrupted ()Verifique se o thread atual foi interrompido.
dumpStack Static void dumpStack ()Imprime um rastreamento de pilha do segmento atual para o fluxo de erro padrão.
suspender public void suspend ()Suspende todos os tópicos. (** o método está obsoleto nas versões mais recentes do Java)
retomar currículo vazio público ()Retomar o tópico suspenso. (** o método está obsoleto nas versões mais recentes do Java)
Pare public void stop ()Pára o tópico. (** o método está obsoleto nas versões mais recentes do Java)

Iremos elaborar esses métodos de thread em nosso próximo tutorial sobre multithreading.

Iniciando um tópico

O método start () que é usado para iniciar o thread executa as seguintes etapas:

  • Inicia uma nova instância de thread com um novo CallStack.
  • O estado do thread é alterado de novo para executável.
  • Quando é a vez da thread, ele executa o método run ().

Implementando a interface ‘executável’

Uma instância de thread também pode ser criada usando a interface Runnable. Para criar uma instância de thread, a classe cujos objetos devem ser executados por um thread deve implementar a interface Runnable.

A interface Runnable tem apenas um método:

public void run () => this method is used to execute the thread.

Exemplo de classe de thread

Agora vamos demonstrar o thread em Java usando a classe de thread.

//class inherited from 'Thread' class ThreadClassDemo extends Thread { private int number; //class constructor public ThreadClassDemo(int number) { this.number = number; } //run method => execution code for thread public void run() { int counter = 0; int numInt = 0; //prints the number till specified number is reached, starting from 10 do { numInt = (int) (counter + 10); System.out.println(this.getName() + ' prints ' + numInt); counter++; } while(numInt != number); System.out.println('** Correct! ' + this.getName() + 'printed ' + counter + ' times.**'); } } public class Main { public static void main(String () args) { System.out.println('Starting thread_1...'); //create a thread class instance Thread thread_1 = new ThreadClassDemo(15); //start the thread thread_1 thread_1.start(); try { //wait for thread_1 to die thread_1.join(); } catch (InterruptedException e) { System.out.println('Thread interrupted.'); } System.out.println('Starting thread_2...'); Thread thread_2 = new ThreadClassDemo(20); //start thread_2 thread_2.start(); System.out.println('main() is ending...'); } }

Resultado

Exemplo de classe de thread

Thread Java usando interface executável

O exemplo a seguir demonstra o uso da interface Runnable para criar uma instância de thread.

//class implements Runnable interface class RunnableDemo implements Runnable { private String message; //class constructor public RunnableDemo(String message) { this.message = message; } //run method public void run() { while(true) { System.out.println(message); } } } public class Main { public static void main(String () args) { //create first thread instance hello Runnable hello = new RunnableDemo('Hello, Greetings!!!'); Thread thread1 = new Thread(hello); thread1.setDaemon(true); //set this thread as daemon thread1.setName('hello'); System.out.println('Starting First thread...'); //start the thread thread1.start(); //create second thread instance bye Runnable bye = new RunnableDemo('Bye for now!!'); Thread thread2 = new Thread(bye); thread2.setPriority(Thread.MIN_PRIORITY); //set priority to min thread2.setDaemon(true); //set as daemon thread System.out.println('Starting goodbye thread...'); //start the thread thread2.start(); System.out.println('main() is ending...'); } }

Resultado

Thread Java usando interface Runnable

Como parar um thread em Java

Vimos os exemplos de thread acima. A partir desses exemplos, sabemos que quando o método run termina a execução, o thread para ou também para devido a algumas exceções.

As versões anteriores do Java tinham um método stop () na classe Thread que podia ser usado para parar diretamente o thread. Mas agora foi descontinuado por razões de segurança. Portanto, precisamos empregar os outros métodos para interromper a thread em execução.

Existem dois métodos que podemos empregar para interromper o encadeamento.

  1. Usando uma variável booleana volátil
  2. Usando interrupções.

Nesta seção, discutiremos esses dois métodos de interrupção de um thread.

Usando uma variável booleana volátil

Nesse método, mantemos uma variável booleana, como sinalizador, para interromper a thread. O thread é executado enquanto a variável booleana é definida como true. No momento em que se torna falso, o thread é interrompido.

A especialidade deste método é que declaramos a variável booleana como “ volátil ”Para que seja sempre lido da memória principal e o programa não possa armazená-lo no cache da CPU. Desta forma, não haverá diferença nos valores configurados e lidos.

A implementação de parar um thread usando uma variável booleana volátil é mostrada abaixo.

class StopThread extends Thread { private volatile boolean stop_flag = true; //initially set to true public void stopRunning() { stop_flag = false; //set stop_flag to false } @Override public void run() { while (stop_flag) { //keep checking value of stop_flag System.out.println('Thread is running...'); } System.out.println('Thread stopped!!!'); } } public class Main { public static void main(String() args) { //create a thread instance StopThread stop_thread = new StopThread(); //start the thread stop_thread.start(); try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } //call stopRunning() method to stop the thread stop_thread.stopRunning(); } }

Resultado

Usando uma variável booleana volátil

Observação: Aqui, mostramos apenas uma parte da saída. O encadeamento pode ser executado por vários minutos antes de parar. Para que possamos obter resultados diferentes em sistemas diferentes.

Usando interrupções

Aqui, a thread é interrompida usando o método interrupt () como já discutimos acima nos métodos de classe de thread. O método interrupt () define o status do thread como interrompido. Este status é passado para o loop while do método run (). Podemos obter o status interrompido usando o método interrupted ().

O programa a seguir demonstra o uso do método interrupt () para interromper o thread.

class StopThread extends Thread { @Override public void run() { while (!Thread.interrupted()) { //check for interrupted status System.out.println('Thread is running...'); } System.out.println('Thread stopped!!!'); } } public class Main { public static void main(String() args) { //create a thread instance StopThread stop_thread = new StopThread(); //start the thread stop_thread.start(); try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } //interrupt the thread stop_thread.interrupt(); } }

Resultado

Usando interrupções - saída

perguntas frequentes

P # 1) Por que usamos multithreading em Java?

Responda: O multithreading permite a execução concorrente ou simultânea de dois ou mais threads em um aplicativo. A execução simultânea maximiza o rendimento e também utiliza a CPU ao máximo.

qual é o melhor downloader de música para telefone Android

P # 2) O que é multithreading? Quais são seus tipos?

Responda: Multithreading significa executar mais de um thread. Essa execução pode ser simultânea ou paralela. Assim, o multithreading tem dois tipos, ou seja, simultâneo ou paralelo.

P # 3) O que é Multithreading vs. Multiprocessing?

Responda: No multithreading, há vários threads para o mesmo processo ou para processos diferentes e esses threads são executados simultaneamente para aumentar a velocidade de computação de um sistema. No multiprocessamento, um sistema possui mais de duas CPUs e vários processos são executados simultaneamente.

P # 4) Quais são as vantagens do multithreading em Java?

Responda: Usando multithreading, podemos executar diferentes partes de um aplicativo simultaneamente usando threads. O multithreading aumenta o rendimento do sistema. O multithreading também maximiza a utilização da CPU, pois diferentes threads usam continuamente a CPU.

P # 5) O multithreading é bom para jogos?

Responda: Sim, especialmente para jogos modernos.

Conclusão

Isso é tudo sobre a introdução de multithreading. Discutimos a simultaneidade e multi-threading em Java neste tutorial. Discutimos a criação de um thread com a classe Thread, bem como a interface Runnable e fornecemos exemplos apropriados.

Também aprendemos os conceitos de um único thread e sua criação em detalhes. Os conceitos de encadeamento incluindo o ciclo de vida de um encadeamento, interrompendo um encadeamento, tipos de encadeamento, etc. foram discutidos neste tutorial.

Também discutimos longamente o multithreading e a simultaneidade em Java. Ao final deste tutorial, o leitor deve ser capaz de compreender facilmente os conceitos de simultaneidade e multithreading e também threads em Java.

=> Veja a série de treinamento simples em Java aqui.

Leitura recomendada

^