O básico de Threads no Java
Tags: java, beginners, braziliandevs, parallelprograming
Published: 2024-05-14 11:00:00

Este artigo aborda tópicos sobre Concorrência e Paralelismo, primeiro de tudo vamos entender o que é uma **thread**.

## O que é uma thread?
Processos de um computador são os programas em execução. Sendo assim, uma thread seria como um subprograma dentro de um processo. É uma linha de execução ou caminho que o processador pode seguir para realizar tarefas. Cada processo pode ter várias threads, permitindo que multiplas tarefas sejam realizadas concorrentemente.

## O que é uma thread no Java?
Geralmente, todos os programas tem pelo menos uma thread, conhecida como thread principal, que é provida pela JVM no começo da execução do programa. Neste ponto, quando a thread principal é dada, o método _main()_ é invocado pela thread principal.

No Java existe uma classe _java.lang.Thread_ usada para criar threads. A JVM permite que uma aplicação tenha multiplas threads rodando concorrentemente. Cada uma tem uma prioridade. Threads com prioridade alta são executadas em precedência as de baixa.

## Criando uma thread no Java
Uma thread pode ser criada de duas formas:
- Extendendo a classe _java.lang.Thread_
Neste caso, a thread é criada pela nova classe que extende a classe _Thread_, criand uma instância desta. O método _run()_ incluí a funcionalidade que supon-se ser implementada pela Thread.
Exemplo:

```java
public class MyThread extends Thread {
    public void run(){
        System.out.println("thread is running...");
    }
    public static void main(String args[]){
        MyThread obj = new MyThread();
        obj.start();
    }
}
```
_start()_ é usado para criar uma nova thread e torna-la executavel.

- Implementando a interface _Runnable_
Este método é mais fácil para criar uma thread. Neste caso, a classe é criada para implementar a interface _Runnable_ e depois o método _run()_.
O código para exeutar a thread deve sempre ser escrito dentro do método _run()_.

```java
public class MyThread implements Runnable {
    public void run(){
        System.out.println("thread is running...");
    }
    public static void main(String args[]){
        Thread t = new Thread(new MyThread());
        t.start();
    }
}
```
O método _start()_ chama o método _run()_. Quando o método start() é chamado, uma nova pilha é dada para a thread, e o método run() é invocado para a nova thread no programa.

## O ciclo de vida da thread
O ciclo de vida da thread em Java refere-se as transformações do estado de uma thread que começa com seu nascimento e termina com sua morte. Quando uma instância de thread é gerada e executada pela chamada do método _start()_ da classe Thread, a thread entra no estado _runnable_. Quando _sleep()_ ou _wait()_ são chamadas a thread entra no modo _non-runnable_.

Há basicamente 4 estados:
1. New
2. Runnable
3. Running
4. Blocked (Non-Runnable)
5. Dead

**New**
Como usamos a classe Thread  para contruir uma entidade thread, a thread nasce e é definida como estando no estado New. Mas, aqui o método start() ainda não foi invocado.

**Runnable**
Uma thread no estado runnable está preperada para executar o código. Quando o start() da nova thread é chamado, esta entra no estado runnable.

No ambiente runnable, a thread está pronta para executada e está esperando a execução na fila.

**Running**
O estado running implica que o processador atribui um intervalo de tempo à thread para execução.

**Blocked**
Quando a thread está viva, mas não pode ser selecionada pelo programador. Está inativa.

**Dead**
Quando a função run() da thread acaba a execução, ela morre automaticamente ou entra no estado dead. Quando a função stop() é invocada, a thread também morre.

## Prioridades das threads
O número de serviços atribuídos a uma thread é designado pela prioridade. A qualquer thread gerada na JVM é dada uma prioridade. A prioridade escala de 1 a 10.
- 1 é conhecido como prioridade mais baixa.
- 5 é conhecido como prioridade padrão.
- 10 representa a prioridade mais alta.

A prioridade da thread principal é 5 por padrão, e cada thread filha vai ter a mesma prioridade da thread pai. Nós podemos ajustar a prioridade de qualquer thread, é recomendado usar as constantes da classe _Thread_:
_Thread.MIN_PRIORITY_;
_Thread.NORM_PRIORITY_;
_Thread.MAX_PRIORITY_;

```java
public class ThreadPriority extends Thread {
    public void run(){
        System.out.println("thread is running..." + 
        Thread.currenThread().getPriority());
    }
    public static void main(String args[]){
        ThreadPriority m1 = new ThreadPriority();
        ThreadPriority m2 = new ThreadPriority();
        m1.setPriority(Thread.MIN_PRIORITY);
        m2.setPriority(Thread.MAX_PRIORITY);
        m1.start();
        m2.start();
    }
}
```

## Referência
[An introdution to the thread in Java](https://www.simplilearn.com/tutorials/java-tutorial/thread-in-java)****