# Task
Imagine you have a **resource** that can be accessed by **only two threads** at a time. Your task is to **create a program** that uses a `semaphore` to **control access** to this resource.

## Conditions:
1. You have a `Resource` **class** with a `use()` **method** that **simulates** the use of a resource, such as **printing a message** and introducing a **delay**;
2. You have a `Worker` **class** that **implements** `Runnable`; in its `run()` **method**, it will attempt to access the **resource** using a `semaphore`;
3. In the `SemaphoreExample` **class**, you have a `main()` **method** that initializes a `semaphore` with permits for **two threads**, along with multiple worker **threads** that will attempt to access the resource;
4. **Ensure that no more than two threads** can use the resource at any given time.

<b>Please do not change anything! </b>You only need to implement the <code>run()</code> method in the <code>Worker</code> class and also implement the logic in the <code>use()</code> method in the <code>Resource</code> class. 

Note

## How should the program work?
You have **5 threads** that want to execute the `use()` **method** simultaneously, but with a `Semaphore`, you **need to limit** the simultaneous execution to **2 threads**. As soon as a **thread** releases the `Semaphore`, another thread can begin executing this **method**. For better clarity in this scenario, it’s **recommended** to introduce a delay within the `use()` **method**.

This course is tailored for those who want to expand their knowledge of multithreading and leverage its capabilities to build efficient, high-performance applications. You'll dive into essential concepts, practical techniques, and best practices in multithreading, empowering you to confidently address complex concurrency issues.

This section will delve into the foundational concepts of multithreading in Java, focusing on the creation and management of threads, and the use of synchronization techniques to avoid conflicts. You’ll also learn how to utilize essential keywords and methods to ensure the accurate and reliable execution of multithreaded programs, providing a solid understanding of how to handle concurrency effectively in your applications.

This section explores synchronized collections in Java, explaining their purpose and the common concurrency issues they are designed to solve. You’ll gain insights into how these collections work, why they are essential in multithreaded environments, and how they help ensure safe and consistent data manipulation when multiple threads access shared resources.

This section covers high-level synchronization mechanisms in Java, such as the use of Lock and Condition, semaphores, barriers, atomic variables, and thread pooling with Executors. Each topic is paired with practical exercises designed to reinforce your understanding and help you apply the theoretical knowledge to real-world scenarios.

This section explores fundamental multithreaded programming patterns and practices such as Producer-Consumer, Fork/Join, ThreadLocal, and asynchronous programming with CompletableFuture. You'll work through examples and see the practical outcomes of these approaches, gaining hands-on experience that will enable you to apply these techniques effectively in real-world applications.

Challenge: Semaphore

Task

Conditions:

How should the program work?