# Tarefa
Imagine que você possui um **recurso** que pode ser acessado por **apenas dois threads** ao mesmo tempo. Sua tarefa é **criar um programa** que utilize um `semaphore` para **controlar o acesso** a esse recurso.

## Condições:
1. Você possui uma **classe** `Resource` com um método `use()` que **simula** o uso de um recurso, como **imprimir uma mensagem** e introduzir um **atraso**;
2. Você possui uma **classe** `Worker` que **implementa** `Runnable`; em seu método `run()`, ela tentará acessar o **recurso** utilizando um `semaphore`;
3. Na **classe** `SemaphoreExample`, você possui um método `main()` que inicializa um `semaphore` com permissões para **dois threads**, juntamente com múltiplos **threads** de trabalho que tentarão acessar o recurso;
4. **Garantir que não mais do que dois threads** possam utilizar o recurso ao mesmo tempo.

<b>Por favor, não altere nada! </b>Você só precisa implementar o método <code>run()</code> na classe <code>Worker</code> e também implementar a lógica no método <code>use()</code> da classe <code>Resource</code>. 

Nota

## Como o programa deve funcionar?
Existem **5 threads** que desejam executar o método `use()` simultaneamente, mas com um `Semaphore`, é **necessário limitar** a execução simultânea para **2 threads**. Assim que uma **thread** libera o `Semaphore`, outra thread pode começar a executar este **método**. Para maior clareza neste cenário, é **recomendado** introduzir um atraso dentro do método `use()`.

Este curso é voltado para quem deseja expandir seus conhecimentos em multithreading e aproveitar seus recursos para construir aplicações eficientes e de alto desempenho. Você irá explorar conceitos essenciais, técnicas práticas e melhores práticas em multithreading, capacitando-se para lidar com questões complexas de concorrência com confiança.

Esta seção abordará os conceitos fundamentais de multithreading em Java, com foco na criação e gerenciamento de threads, além do uso de técnicas de sincronização para evitar conflitos. Você também aprenderá a utilizar palavras-chave e métodos essenciais para garantir a execução precisa e confiável de programas multithreaded, proporcionando uma compreensão sólida sobre como lidar com concorrência de forma eficaz em suas aplicações.

Esta seção explora as coleções sincronizadas em Java, explicando seu propósito e os problemas comuns de concorrência que elas foram projetadas para resolver. Você obterá insights sobre como essas coleções funcionam, por que são essenciais em ambientes multithread e como ajudam a garantir uma manipulação de dados segura e consistente quando múltiplas threads acessam recursos compartilhados.

Esta seção aborda mecanismos de sincronização de alto nível em Java, como o uso de Lock e Condition, semáforos, barreiras, variáveis atômicas e thread pooling com Executors. Cada tópico é acompanhado de exercícios práticos projetados para reforçar sua compreensão e ajudar na aplicação do conhecimento teórico em cenários do mundo real.

Esta seção explora padrões e práticas fundamentais de programação multithread, como produtor-consumidor, fork/join, ThreadLocal e programação assíncrona com CompletableFuture. Você irá analisar exemplos e observar os resultados práticos dessas abordagens, adquirindo experiência prática que permitirá aplicar essas técnicas de forma eficaz em aplicações do mundo real.

Desafio: Semáforo

Tarefa

Condições:

Como o programa deve funcionar?

Awesome!

Desafio: Semáforo

Tarefa

Condições:

Como o programa deve funcionar?