public interface Callable<V> {
    V call() throws Exception;
}

import java.util.concurrent.*;

public class CallableExample {
    public static void main(String[] args) {
        // Создаем ExecutorService с пулом потоков
        ExecutorService executor = Executors.newFixedThreadPool(2);

        // Задача, которая возвращает результат
        Callable<Integer> task = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                // Пример вычислений
                return 123;
            }
        };

        // Выполняем задачу и получаем объект Future
        Future<Integer> future = executor.submit(task);

        try {
            // Получаем результат выполнения задачи
            Integer result = future.get(); // блокирует текущий поток до получения результата
            System.out.println("Результат: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            executor.shutdown();
        }
    }
}

import java.util.concurrent.*;

public class CallableWithException {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();

        Callable<String> task = () -> {
            // Исключение для демонстрации обработки ошибок
            if (true) {
                throw new IllegalArgumentException("Произошла ошибка");
            }
            return "Успешно выполнено!";
        };

        Future<String> future = executor.submit(task);

        try {
            String result = future.get(); // Это вызовет исключение, если задача выбросит ошибку
            System.out.println("Результат: " + result);
        } catch (ExecutionException e) {
            System.out.println("Ошибка выполнения задачи: " + e.getCause());
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            executor.shutdown();
        }
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    public static void main(String[] args) {
        // Семафор с 2 разрешениями
        Semaphore semaphore = new Semaphore(2);

        // Пул из 5 потоков
        ExecutorService executor = Executors.newFixedThreadPool(5);

        for (int i = 0; i < 5; i++) {
            final int threadId = i;
            executor.submit(() -> {
                try {
                    System.out.println("Thread " + threadId + " is waiting for permit...");
                    semaphore.acquire(); // Получаем разрешение
                    System.out.println("Thread " + threadId + " acquired permit.");
                    Thread.sleep(2000); // Имитируем использование ресурса
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    System.out.println("Thread " + threadId + " released permit.");
                    semaphore.release(); // Освобождаем разрешение
                }
            });
        }

        executor.shutdown();
    }
}

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
    public static void main(String[] args) throws InterruptedException {
        // Создаем CountDownLatch с начальным значением 3
        CountDownLatch latch = new CountDownLatch(3);

        // Потоки, выполняющие задачи
        Runnable task = () -> {
            System.out.println(Thread.currentThread().getName() + " is working...");
            try {
                Thread.sleep(1000); // Имитация работы
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            System.out.println(Thread.currentThread().getName() + " finished.");
            latch.countDown(); // Уменьшаем значение счетчика
        };

        // Запускаем 3 потока
        for (int i = 0; i < 3; i++) {
            new Thread(task).start();
        }

        System.out.println("Main thread is waiting for tasks to finish...");
        latch.await(); // Ждем, пока счетчик не станет равен 0
        System.out.println("All tasks are finished. Main thread resumes.");
    }
}

Semaphore semaphore = new Semaphore(10); // Максимум 10 соединений

// Каждый поток пытается установить соединение
Runnable connectTask = () -> {
    try {
        semaphore.acquire();
        System.out.println("Connection established by " + Thread.currentThread().getName());
        Thread.sleep(2000); // Используем соединение
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    } finally {
        System.out.println("Connection released by " + Thread.currentThread().getName());
        semaphore.release();
    }
};

CountDownLatch latch = new CountDownLatch(3);

Runnable loadData = () -> {
    try {
        System.out.println(Thread.currentThread().getName() + " loading data...");
        Thread.sleep(1000);
        latch.countDown();
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
};

new Thread(loadData).start();
new Thread(loadData).start();
new Thread(loadData).start();

latch.await();
System.out.println("All data loaded. Proceeding to next step.");