import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class SubmitExample {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(2);

        Callable<Integer> task1 = () -> {
            Thread.sleep(1000);
            return 10;
        };

        Callable<Integer> task2 = () -> {
            Thread.sleep(2000);
            return 20;
        };

        Future<Integer> future1 = executorService.submit(task1);
        Future<Integer> future2 = executorService.submit(task2);

        try {
            System.out.println("Result of task1: " + future1.get());
            System.out.println("Result of task2: " + future2.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }

        executorService.shutdown();
    }
}

public class InvokeExample {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);

        List<Callable<Integer>> tasks = Arrays.asList(
                () -> {
                    Thread.sleep(1000);
                    return 1;
                },
                () -> {
                    Thread.sleep(2000);
                    return 2;
                },
                () -> {
                    Thread.sleep(3000);
                    return 3;
                }
        );

        try {
            List<Future<Integer>> results = executorService.invokeAll(tasks);
            for (Future<Integer> result : results) {
                System.out.println("Result: " + result.get());
            }

            Integer anyResult = executorService.invokeAny(tasks);
            System.out.println("First completed task result: " + anyResult);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }

        executorService.shutdown();
    }
}

executorService.shutdown();

List<Runnable> notExecutedTasks = executorService.shutdownNow();

try {
    if (!executorService.awaitTermination(60, TimeUnit.SECONDS)) {
        executorService.shutdownNow();
    }
} catch (InterruptedException e) {
    executorService.shutdownNow();
}

import java.util.concurrent.ConcurrentHashMap;

public class ComputeIfAbsentExample {

    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> concurrentMap = new ConcurrentHashMap<>();

        // Добавление элементов в карту
        concurrentMap.put("One", 1);
        concurrentMap.put("Two", 2);

        // Использование computeIfAbsent для добавления значения, если ключ отсутствует
        concurrentMap.computeIfAbsent("Three", key -> 3);
        concurrentMap.computeIfAbsent("One", key -> 10); // Это значение не будет добавлено, так как ключ уже существует

        System.out.println(concurrentMap); // {One=1, Two=2, Three=3}
    }
}

import java.util.concurrent.ConcurrentHashMap;
import java.util.function.BiConsumer;

public class ForEachExample {

    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> concurrentMap = new ConcurrentHashMap<>();
        concurrentMap.put("One", 1);
        concurrentMap.put("Two", 2);
        concurrentMap.put("Three", 3);

        // Параллельная обработка элементов карты
        concurrentMap.forEach(1, (key, value) -> {
            System.out.println("Key: " + key + ", Value: " + value);
        });
    }
}

import java.util.concurrent.ConcurrentHashMap;

public class ReduceExample {

    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> concurrentMap = new ConcurrentHashMap<>();
        concurrentMap.put("One", 1);
        concurrentMap.put("Two", 2);
        concurrentMap.put("Three", 3);

        // Параллельное суммирование значений карты
        int sum = concurrentMap.reduceValues(1, Integer::sum);
        System.out.println("Sum of values: " + sum); // Output: Sum of values: 6
    }
}

import java.util.concurrent.ConcurrentHashMap;

public class WordCountExample {

    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> wordCounts = new ConcurrentHashMap<>();
        String[] words = {"apple", "banana", "apple", "orange", "banana", "apple"};

        for (String word : words) {
            wordCounts.merge(word, 1, Integer::sum);
        }

        System.out.println(wordCounts); // {apple=3, banana=2, orange=1}
    }
}

import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;

public class ComputationCacheExample {

    private final ConcurrentHashMap<Integer, String> cache = new ConcurrentHashMap<>();

    public String compute(Integer key, Function<Integer, String> computation) {
        return cache.computeIfAbsent(key, computation);
    }

    public static void main(String[] args) {
        ComputationCacheExample example = new ComputationCacheExample();

        Function<Integer, String> computation = key -> {
            try {
                Thread.sleep(1000); // Симуляция долгого вычисления
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Result for " + key;
        };

        System.out.println(example.compute(1, computation)); // Вычисление и кэширование
        System.out.println(example.compute(1, computation)); // Использование закэшированного значения
    }
}

public class LivelockExample {

    static class Worker {
        private boolean active = true;

        public synchronized void work(Worker other) {
            while (active) {
                System.out.println(Thread.currentThread().getName() + " is working...");
                try { Thread.sleep(50); } catch (InterruptedException e) {}

                if (other.isActive()) {
                    System.out.println(Thread.currentThread().getName() + " is waiting...");
                    continue;
                }
                break;
            }
        }

        public synchronized void setActive(boolean active) {
            this.active = active;
        }

        public synchronized boolean isActive() {
            return active;
        }
    }

    public static void main(String[] args) {
        Worker w1 = new Worker();
        Worker w2 = new Worker();

        Thread t1 = new Thread(() -> w1.work(w2), "Worker 1");
        Thread t2 = new Thread(() -> w2.work(w1), "Worker 2");

        t1.start();
        t2.start();
    }
}

private static volatile boolean running = true;

public void run() {
    while (running) {
        // Выполняем задачу
    }
}

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.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.");