Threads são usadas para executar processos simultaneamente. A classe Thread e interface Runnable permitem manipular threads. Synchronized garante acesso exclusivo a recursos compartilhados para evitar race conditions, mas reduz performance. Variáveis atômicas permitem alterar recursos compartilhados sem filas ou conflitos. Semaphores limitam o número de threads que podem acessar um recurso de cada vez. Race conditions e deadlocks são problemas com concorrência.

1. Threads
Concorrência(synchronized e atomicidade),
Semaphores e thread issues

2. As threads são usada para que dois ou mais processos possam ser executados
ao mesmo tempo, e a manipulação delas é feita pela classe Thread, ou interface
Runnable.
● Interface Runnable: interface funcional com o método abstrato run();
● Classe Thread: classe que implementa a interface Runnable, e utiliza seu
construtor para iniciar uma thread, possuindo métodos para manipulação de
threads como: start(), sleep() e currentThread().

3. Synchronized
Acontece quando duas ou mais threads são executadas e acessam o mesmo
recurso ao mesmo tempo, o que pode levar a uma race condition.
Para evitar essa situação, é usada a palavra-chave synchronized (na assinatura
do método ou um bloco de código) que faz com que somente uma thread possa
acessar aquele recurso por vez.
O que gera uma perda de performance, já que vai criar uma fila de threads para
acessar aquele recurso.
Exemplo: https://github.com/pedrohubner/estudos/blob/master/Codigos/src/main/java/com/threads/sync/Counter.java

4. Exemplo Synchronized

5. Atomicidade
Para evitar a queda de performance que o synchronized gera, se usa as variáveis
atômicas (como AtomicInteger).
Que permite que duas ou mais threads acessem determinando recurso sem criar
uma fila de um acesso por vez e sem que haja conflitos dos valores dos recursos,
já que utilizando as variáveis atômicas, qualquer alteração é salva diretamente na
memória.
Exemplo:
https://github.com/pedrohubner/estudos/blob/master/Codigos/src/main/java/com/threads/atomic/Counter.java

6. Exemplo Atomicidade

7. Semaphore
A classe Semaphore possui métodos que limitam a quantidade de Threads que
poderão acessar determinado recurso.
● Semaphore(int permits): construtor em que é definido quantas threads
poderão ter acesso a algum recurso ao mesmo tempo;
● acquire(): método que dá permissão à thread de acessar determinado
recurso, caso o número de permissões já tenha sido atingido, uma fila de
threads é criada esperando a próxima permissão;
● release(): método responsável por “avisar” que uma thread terminou de
utilizar o recurso, dando permissão à próxima thread.
Exemplo: https://github.com/pedrohubner/shoppingcart/blob/master/src/main/java/com/app/thread/CartThread.java

8. Exemplo Semaphore

9. Thread issues
● Race condition: quando há a concorrência de duas threads tentando
acessar um mesmo recurso, ao mesmo tempo, e alterar seu valor.
● Deadlock: acontece quando uma thread-1 espera uma thread-2 liberar o
acesso ao recurso, porém, a thread-2 também está esperando a thread-1
liberar o acesso, o que faz com que nenhuma das duas seja executada.

10. Exemplo Racecondition

11. Exemplo DeadLock