Java for Beginner

CompletableFuture в Java

CompletableFuture — это расширение Future, которое предоставляет мощные средства для работы с асинхронными задачами. Он позволяет легко комбинировать и связывать асинхронные операции, использовать методы обратного вызова (callback) и работать с исключениями.

Создание и выполнение задач с помощью CompletableFuture

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class CompletableFutureExample {

    public static void main(String[] args) {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return 42;
        });

        System.out.println("Doing something else while the task is running...");

        try {
            Integer result = future.get();
            System.out.println("Task completed with result: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

Методы thenApply, thenAccept и thenRun

thenApply(Function): Применяет функцию к результату завершенного CompletableFuture и возвращает новый CompletableFuture.
thenAccept(Consumer): Принимает потребителя для обработки результата завершенного CompletableFuture.
thenRun(Runnable): Выполняет действие после завершения CompletableFuture, не используя его результат.

Пример использования:

import java.util.concurrent.CompletableFuture;

public class CompletableFutureChainingExample {

    public static void main(String[] args) {
        CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return 42;
        }).thenApply(result -> result * 2)
          .thenAccept(result -> System.out.println("Result: " + result))
          .thenRun(() -> System.out.println("Task completed!"));
    }
}

Обработка исключений

CompletableFuture предоставляет методы для обработки исключений, такие как exceptionally, handle и whenComplete.

Пример обработки исключений:

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class CompletableFutureExceptionHandlingExample {

    public static void main(String[] args) {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (true) {
                throw new RuntimeException("Something went wrong!");
            }
            return 42;
        }).exceptionally(ex -> {
            System.out.println("Exception: " + ex.getMessage());
            return -1;
        });

        try {
            Integer result = future.get();
            System.out.println("Result: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

#Java #Training #Multithreading #Medium

142 viewsДен, 13:03

Java for Beginner

Комбинирование CompletableFuture

Методы thenCombine и thenCompose позволяют комбинировать несколько CompletableFuture.

Пример использования thenCombine:

import java.util.concurrent.CompletableFuture;

public class CompletableFutureCombineExample {

    public static void main(String[] args) {
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return 42;
        });

        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return 24;
        });

        CompletableFuture<Integer> combinedFuture = future1.thenCombine(future2, (result1, result2) -> result1 + result2);

        try {
            System.out.println("Combined result: " + combinedFuture.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

Пример использования thenCompose:

import java.util.concurrent.CompletableFuture;

public class CompletableFutureComposeExample {

    public static void main(String[] args) {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return 42;
        });

        CompletableFuture<Integer> composedFuture = future.thenCompose(result -> 
            CompletableFuture.supplyAsync(() -> result * 2)
        );

        try {
            System.out.println("Composed result: " + composedFuture.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

#Java #Training #Multithreading #Medium

133 viewsДен, 13:03

Java for Beginner

Многопоточность в Java: volatile и Immutable Classes

Volatile

Ключевое слово volatile в Java используется для обозначения переменных, которые могут быть изменены различными потоками. Переменная, объявленная как volatile, гарантирует, что все потоки будут читать ее актуальное значение из основной памяти, а не из кэша процессора. Это помогает избежать некоторых проблем с видимостью, которые могут возникнуть в многопоточных приложениях.

Пример использования volatile

public class VolatileExample {
    private volatile boolean running = true;

    public void start() {
        new Thread(() -> {
            while (running) {
                System.out.println("Thread is running...");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("Thread stopped.");
        }).start();
    }

    public void stop() {
        running = false;
    }

    public static void main(String[] args) {
        VolatileExample example = new VolatileExample();
        example.start();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        example.stop();
    }
}

В этом примере поток проверяет значение переменной running и останавливается, когда она становится false. Использование volatile гарантирует, что изменения переменной running будут видны всем потокам.

Immutable Classes

Иммутабельные (неизменяемые) классы — это классы, состояния объектов которых не могут быть изменены после создания. Они особенно полезны в многопоточной среде, так как обеспечивают безопасность потоков (thread-safety) без необходимости использования синхронизации.

Пример неизменяемого класса

public final class ImmutablePerson {
    private final String name;
    private final int age;

    public ImmutablePerson(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
    
    @Override
    public String toString() {
        return "ImmutablePerson{name='" + name + "', age=" + age + "}";
    }
    
    public static void main(String[] args) {
        ImmutablePerson person = new ImmutablePerson("John", 30);
        System.out.println(person);
        // person.setName("Doe"); // This would cause a compile error
    }
}

В этом примере класс ImmutablePerson является неизменяемым, потому что все его поля final, и они инициализируются только один раз в конструкторе.

Преимущества неизменяемых классов

Потокобезопасность: Нет необходимости в синхронизации, так как состояние объекта не может быть изменено после создания.
Простота использования: Меньше ошибок, связанных с изменением состояния.
Упрощенная разработка: Легче проектировать и отлаживать.

#Java #Training #Multithreading #Medium #Volatile #Immutable_Classes

139 viewsДен, edited 05:48

Java for Beginner

Многопоточность в Java: Deadlock

Deadlock (взаимная блокировка) — это состояние, при котором два или более потоков блокируют друг друга, ожидая освобождения ресурсов, занятых друг другом. Это приводит к тому, что ни один из потоков не может продолжать выполнение.

public class DeadlockExample {

    private final Object lock1 = new Object();
    private final Object lock2 = new Object();

    public void method1() {
        synchronized (lock1) {
            System.out.println("Thread 1: Holding lock 1...");
            try { Thread.sleep(100); } catch (InterruptedException e) {}
            synchronized (lock2) {
                System.out.println("Thread 1: Holding lock 1 & 2...");
            }
        }
    }

    public void method2() {
        synchronized (lock2) {
            System.out.println("Thread 2: Holding lock 2...");
            try { Thread.sleep(100); } catch (InterruptedException e) {}
            synchronized (lock1) {
                System.out.println("Thread 2: Holding lock 2 & 1...");
            }
        }
    }

    public static void main(String[] args) {
        DeadlockExample example = new DeadlockExample();
        
        Thread thread1 = new Thread(example::method1);
        Thread thread2 = new Thread(example::method2);

        thread1.start();
        thread2.start();
    }
}

В этом примере возникает deadlock, потому что thread1 захватывает lock1 и ждет lock2, в то время как thread2 захватывает lock2 и ждет lock1. Таким образом, оба потока оказываются в состоянии взаимной блокировки.

Способы предотвращения Deadlock

Иерархия блокировок: Всегда захватывайте ресурсы в определенном порядке.
Тайм-ауты: Используйте методы с тайм-аутами для захвата блокировок, такие как tryLock из ReentrantLock.
Избегайте вложенных блокировок: Старайтесь минимизировать количество вложенных блокировок.

Пример с использованием tryLock

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.TimeUnit;

public class DeadlockAvoidanceExample {

    private final Lock lock1 = new ReentrantLock();
    private final Lock lock2 = new ReentrantLock();

    public void method1() {
        try {
            if (lock1.tryLock(50, TimeUnit.MILLISECONDS)) {
                try {
                    System.out.println("Thread 1: Holding lock 1...");
                    Thread.sleep(50);
                    if (lock2.tryLock(50, TimeUnit.MILLISECONDS)) {
                        try {
                            System.out.println("Thread 1: Holding lock 1 & 2...");
                        } finally {
                            lock2.unlock();
                        }
                    }
                } finally {
                    lock1.unlock();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void method2() {
        try {
            if (lock2.tryLock(50, TimeUnit.MILLISECONDS)) {
                try {
                    System.out.println("Thread 2: Holding lock 2...");
                    Thread.sleep(50);
                    if (lock1.tryLock(50, TimeUnit.MILLISECONDS)) {
                        try {
                            System.out.println("Thread 2: Holding lock 2 & 1...");
                        } finally {
                            lock1.unlock();
                        }
                    }
                } finally {
                    lock2.unlock();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

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

        Thread thread1 = new Thread(example::method1);
        Thread thread2 = new Thread(example::method2);

        thread1.start();
        thread2.start();
    }
}

В этом примере tryLock используется для попытки захвата блокировок с тайм-аутом, что предотвращает возникновение deadlock.

#Java #Training #Multithreading #Medium #Deadlock

147 viewsДен, edited 13:54

Java for Beginner

Многопоточность в Java: Пул потоков

Пул потоков (Thread Pool) — это механизм управления коллекцией потоков, предназначенный для выполнения задач. Потоки в пуле повторно используются для выполнения нескольких задач, что позволяет сократить накладные расходы на создание и уничтожение потоков и повысить производительность многопоточных приложений.

Зачем нужен пул потоков?

Улучшение производительности: Создание нового потока — дорогостоящая операция. Пул потоков позволяет избежать этих накладных расходов, повторно используя уже существующие потоки.
Контроль над количеством потоков: Пул потоков позволяет ограничить максимальное количество одновременно работающих потоков, что предотвращает исчерпание ресурсов системы.
Упрощение управления задачами: Пул потоков предоставляет удобные методы для отправки задач на выполнение, что упрощает управление многопоточными задачами.

Создание пула потоков

В Java для работы с пулом потоков используется класс ExecutorService, который предоставляет методы для управления потоками и выполнения задач. Воспользоваться готовыми реализациями можно с помощью класса Executors.

Пример создания пула потоков с фиксированным числом потоков

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

public class FixedThreadPoolExample {

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

        for (int i = 0; i < 5; i++) {
            int taskId = i;
            executorService.submit(() -> {
                System.out.println("Task " + taskId + " is running in thread " + Thread.currentThread().getName());
                try {
                    Thread.sleep(2000); // Симуляция долгой задачи
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Task " + taskId + " completed");
            });
        }

        executorService.shutdown();
    }
}

В этом примере создается пул из трех потоков, и пять задач отправляются на выполнение. Задачи будут выполняться параллельно, но не более трех одновременно.

Виды пулов потоков

FixedThreadPool: Пул с фиксированным числом потоков. Новый поток не создается, если все потоки заняты, до тех пор, пока один из них не освободится.

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);

CachedThreadPool: Пул, который создает потоки по мере необходимости, но переиспользует старые потоки, если они доступны. Подходит для выполнения большого количества коротких задач.

ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

SingleThreadExecutor: Пул с единственным потоком, выполняющий задачи последовательно.

ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();

ScheduledThreadPool: Пул, который позволяет выполнять задачи с задержкой или периодически.

ExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);

#Java #Training #Multithreading #Medium

154 viewsДен, 05:37

Java for Beginner

Многопоточность в Java: ExecutorService

ExecutorService — это интерфейс, который предоставляет методы для управления жизненным циклом потоков и для выполнения задач. Он является частью фреймворка java.util.concurrent и предоставляет гибкие способы работы с потоками.

Основные методы ExecutorService

submit(Runnable task): Отправляет задачу на выполнение и возвращает объект Future, представляющий эту задачу.
submit(Callable<T> task): Отправляет задачу, возвращающую результат, на выполнение и возвращает объект Future.
invokeAll(Collection<? extends Callable<T>> tasks): Выполняет все задачи из коллекции и возвращает список объектов Future.
invokeAny(Collection<? extends Callable<T>> tasks): Выполняет все задачи из коллекции и возвращает результат одной из успешно завершенных задач.
shutdown(): Начинает плавное завершение работы пула, позволяя выполнению текущих задач завершиться.
shutdownNow(): Пытается немедленно завершить выполнение всех задач.

Пример использования submit

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();
    }
}

Пример использования invokeAll и invokeAny

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

Правильное завершение ExecutorService важно для предотвращения утечек ресурсов и корректного завершения программы.

shutdown(): Начинает плавное завершение. Новые задачи не принимаются, но уже отправленные задачи продолжают выполнение.

executorService.shutdown();

shutdownNow(): Пытается немедленно завершить все задачи, возвращает список задач, которые не были начаты.

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

awaitTermination(long timeout, TimeUnit unit): Ожидает завершения всех задач в течение указанного времени.

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

#Java #Training #Multithreading #Medium #ExecutorService

147 viewsДен, edited 13:43

Java for Beginner

Concurrency

Concurrency (параллельность) — это способность программы выполнять несколько задач одновременно. В контексте Java, это включает использование многопоточности и синхронизации для обеспечения корректного выполнения параллельных операций.

Коллекции и многопоточность

Стандартные коллекции, такие как ArrayList, HashMap, HashSet и другие, не являются потокобезопасными. Это означает, что если несколько потоков одновременно выполняют операции чтения и записи с этими коллекциями, могут возникнуть проблемы, такие как:

Несогласованность данных: Данные могут быть повреждены или потеряны.
Исключения времени выполнения: Например, ConcurrentModificationException.

Для решения этих проблем в Java были введены потокобезопасные коллекции из пакета java.util.concurrent.

ConcurrentHashMap — это потокобезопасная реализация HashMap, которая позволяет нескольким потокам одновременно выполнять операции чтения и записи. В отличие от синхронизированного HashMap, ConcurrentHashMap использует механизм сегментации (локов), что позволяет повысить производительность за счет уменьшения количества блокировок.

Пример использования ConcurrentHashMap

import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentHashMapExample {

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

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

        // Создание потоков для параллельного чтения и записи
        Thread writerThread = new Thread(() -> {
            for (int i = 4; i <= 6; i++) {
                concurrentMap.put("Number " + i, i);
                System.out.println("Added: Number " + i);
                try {
                    Thread.sleep(100); // Симуляция задержки
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread readerThread = new Thread(() -> {
            for (int i = 1; i <= 6; i++) {
                System.out.println("Value for Number " + i + ": " + concurrentMap.get("Number " + i));
                try {
                    Thread.sleep(150); // Симуляция задержки
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        writerThread.start();
        readerThread.start();

        try {
            writerThread.join();
            readerThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

В этом примере ConcurrentHashMap используется для параллельных операций чтения и записи. Поток writerThread добавляет элементы в карту, в то время как поток readerThread считывает значения из карты. Благодаря использованию ConcurrentHashMap данные остаются согласованными, и исключения времени выполнения не возникают.

Основные методы ConcurrentHashMap

put(K key, V value): Добавляет пару ключ-значение в карту.
get(Object key): Возвращает значение, связанное с указанным ключом.
remove(Object key): Удаляет пару ключ-значение из карты.
replace(K key, V value): Заменяет значение, связанное с указанным ключом, на новое значение.
computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction): Если ключ отсутствует в карте, вычисляет значение и добавляет его в карту.

#Java #Training #Multithreading #Medium

155 viewsДен, 05:37

Java for Beginner

Продвинутые методы ConcurrentHashMap

ConcurrentHashMap предоставляет дополнительные методы для более тонкого управления данными и выполнения атомарных операций.

Пример использования computeIfAbsent

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}
    }
}

Использование forEach и reduce

ConcurrentHashMap поддерживает методы для параллельной обработки данных, такие как forEach и reduce.

Пример использования forEach

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);
        });
    }
}

Пример использования reduce

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
    }
}

Примеры использования ConcurrentHashMap в реальных задачах

Пример 1: Подсчет количества слов

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}
    }
}

Пример 2: Кэширование вычислений

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)); // Использование закэшированного значения
    }
}

#Java #Training #Multithreading #Medium

151 viewsДен, 13:38

Java for Beginner

Недавнее обсуждение многопоточности в нашем чате, подтолкнуло меня восполнить недостатки знаний в этой области Java. 🧐

Дополняю темы про распространенные ошибки многопоточности.

Распространенные ошибки многопоточности

Race Condition (Состояние гонки)

Race Condition — это ситуация, когда поведение программы зависит от порядка или своевременности выполнения потоков. Оно возникает, когда несколько потоков одновременно обращаются к одному и тому же ресурсу (например, переменной или объекту), и хотя бы один из них изменяет его.

Пример Race Condition:

public class Counter {
    private int count = 0;

    public void increment() {
        count++; // Неатомарная операция: чтение, увеличение, запись
    }

    public int getCount() {
        return count;
    }
}

public class RaceConditionExample {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println("Final count: " + counter.getCount()); // Ожидаем 2000, но результат может быть меньше
    }
}

Почему Race Condition?

count++ не является атомарной операцией.

Она состоит из трех шагов:
Чтение текущего значения count.
Увеличение значения.
Запись нового значения обратно в переменную.

Если оба потока прочитают одно и то же значение до записи, итоговое значение будет некорректным.

Deadlock (Взаимная блокировка)

Deadlock — ситуация, при которой два или более потоков блокируют друг друга, ожидая освобождения ресурсов.

Пример Deadlock:

public class DeadlockExample {

    private final Object lock1 = new Object();
    private final Object lock2 = new Object();

    public void method1() {
        synchronized (lock1) {
            System.out.println("Thread 1: Holding lock1...");
            try { Thread.sleep(50); } catch (InterruptedException e) {}

            synchronized (lock2) {
                System.out.println("Thread 1: Acquired lock2.");
            }
        }
    }

    public void method2() {
        synchronized (lock2) {
            System.out.println("Thread 2: Holding lock2...");
            try { Thread.sleep(50); } catch (InterruptedException e) {}

            synchronized (lock1) {
                System.out.println("Thread 2: Acquired lock1.");
            }
        }
    }

    public static void main(String[] args) {
        DeadlockExample demo = new DeadlockExample();

        Thread t1 = new Thread(demo::method1);
        Thread t2 = new Thread(demo::method2);

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

Что происходит:
Поток 1 захватывает lock1 и ждет lock2.
Поток 2 захватывает lock2 и ждет lock1.
Оба потока застревают, ожидая освобождения ресурсов друг от друга.

#Java #Training #Multithreading #Medium #Race_Condition #Livelock #Starvation #Thread_Interference #Memory_Consistency_Errors #Multithreading_errors

116 views06:59

Java for Beginner

Livelock (Живая блокировка)

Livelock похож на Deadlock, но здесь потоки не блокируются, а продолжают изменять свое состояние в попытке избежать конфликта, не продвигаясь дальше.

Пример Livelock:

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();
    }
}

Что происходит:
Оба потока продолжают "уступать" друг другу, не завершив работу.

Starvation (Голодание)

Starvation — ситуация, когда поток постоянно лишается доступа к ресурсу из-за того, что другие потоки с более высоким приоритетом занимают его.

Причина: Использование приоритетов потоков, где высокоприоритетные потоки блокируют низкоприоритетные.

Thread Interference (Конфликт потоков)

Это ситуация, похожая на Race Condition, когда несколько потоков одновременно читают и изменяют общие данные, приводя к непредсказуемым результатам.

Пример:
Потоки выполняют операции на одной переменной без синхронизации, что приводит к некорректным итоговым значениям.

Memory Consistency Errors (Ошибки согласованности памяти)

Эти ошибки возникают, когда один поток изменяет данные, но другие потоки видят устаревшее состояние этих данных.

Причина: Использование кэша процессора.
Переменная, измененная в одном потоке, может не быть видимой для других потоков.

Решение:
Использование volatile для обеспечения видимости изменений.

private static volatile boolean running = true;

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

Как предотвратить ошибки многопоточности

Использование синхронизации:
synchronized блоки или методы.
ReentrantLock для более гибкого управления блокировкой.

Использование атомарных типов:
Классы из пакета java.util.concurrent.atomic:
AtomicInteger, AtomicBoolean, AtomicReference.

Использование высокоуровневых утилит:
ExecutorService для управления потоками.
CountDownLatch, Semaphore, CyclicBarrier.

Избегание Deadlock:
Всегда захватывать блокировки в одном и том же порядке.
Использование таймаутов при ожидании захвата.

Проверка и отладка:
Инструменты отладки (например, jstack, VisualVM) для анализа состояния потоков.
Логирование текущих блокировок и их владельцев.

#Java #Training #Multithreading #Medium #Race_Condition #Livelock #Starvation #Thread_Interference #Memory_Consistency_Errors #Multithreading_errors

129 viewsedited 06:59

Java for Beginner

Продолжаем устранять пробелы в многопоточке Java. Сегодня рассмотрим интерфейс Callable.

Callable

Callable — это функциональный интерфейс в Java, который представляет задачу, выполняемую в отдельном потоке. Он был введен в Java 5 вместе с пакетами для многозадачности (java.util.concurrent), и его основное назначение — предоставить способ выполнения асинхронных операций, которые могут вернуть результат.

1. Основные особенности Callable

Интерфейс Callable аналогичен интерфейсу Runnable, но с двумя важными отличиями:
Возвращаемое значение: В отличие от Runnable, который не возвращает значения (void run()), метод call() интерфейса Callable может возвращать результат. Это позволяет возвращать какие-либо данные (например, результат вычислений или ошибку).
Исключения: Метод call() может бросать исключения, в отличие от метода run() интерфейса Runnable, который не может выбрасывать проверяемые исключения.
Возвращаемое значение: Метод call() возвращает объект типа V (генерик), который может быть любым типом. Это возвращаемое значение удобно для получения результатов выполнения асинхронных задач.

Использование с ExecutorService:
Задачи, реализующие Callable, часто выполняются через ExecutorService, который предоставляет методы для асинхронного выполнения таких задач.

2. Методы интерфейса Callable

call() — это основной метод интерфейса. Он выполняет задачу и возвращает результат типа V. Также этот метод может выбрасывать проверяемые исключения (Exception), что отличает его от метода run() интерфейса Runnable, который не может этого делать.

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

3. Основные классы и интерфейсы для работы с Callable

Чтобы эффективно использовать интерфейс Callable, в Java существует несколько классов и интерфейсов для работы с многозадачностью:
ExecutorService — интерфейс для управления пулом потоков и выполнения задач в асинхронном режиме.
Future<V> — интерфейс, который представляет результат асинхронной задачи. Он используется для получения результата выполнения Callable после завершения его работы. Через объект Future можно проверить статус выполнения задачи, отменить её или получить результат (если задача завершена).

Пример использования Callable и ExecutorService:

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();
        }
    }
}

4. Методы интерфейса Future

Объект Future, который возвращается методом submit() объекта ExecutorService, предоставляет несколько полезных методов для работы с результатом асинхронной задачи:
get(): Блокирует текущий поток до получения результата выполнения задачи. Если задача завершена с ошибкой, этот метод выбрасывает ExecutionException.
get(long timeout, TimeUnit unit): Блокирует текущий поток до получения результата или до истечения времени ожидания.
cancel(boolean mayInterruptIfRunning): Отменяет задачу. Если задача не начала выполнение, она будет отменена. Если она уже выполняется, её можно прервать, если указан параметр mayInterruptIfRunning = true.
isCancelled(): Проверяет, была ли задача отменена.
isDone(): Проверяет, завершена ли задача (независимо от того, успешно ли она завершилась).

#Java #Training #Multithreading #Callable

132 views05:59

Java for Beginner

5. Преимущества использования Callable

Возврат результата: В отличие от Runnable, который не возвращает результата, Callable может возвращать значения, что делает его полезным для вычислений, которые должны вернуть результат.
Обработка исключений: Callable позволяет методам выбрасывать проверяемые исключения, что полезно для обработки ошибок в многозадачных приложениях.
Параллельное выполнение: Использование ExecutorService с задачами типа Callable позволяет эффективно управлять пулом потоков, распределяя задачи между потоками.

6. Нюансы использования Callable

Блокировка с get(): Важно помнить, что метод get() блокирует текущий поток до тех пор, пока задача не завершится. Если вы вызываете get() на множестве задач, это может привести к значительным задержкам, если задачи не завершены вовремя.
Исключения в call(): Поскольку метод call() может выбрасывать исключения, важно правильно их обрабатывать в блоке try-catch, особенно если задача выполняет долгосрочную или ресурсозатратную операцию.
Параллельность: Если задач несколько, ExecutorService с пулом потоков позволяет выполнять их параллельно, но стоит быть осторожным с использованием ресурсов, так как слишком много потоков может привести к перегрузке системы.
Атомарность операций: Если задачи выполняют изменения общих данных, важно учитывать синхронизацию, чтобы избежать конфликтов между потоками.
Использование с Callable и Future для делегирования работы: Параллельное выполнение задач через ExecutorService и использование объектов Future позволяет строить более сложные асинхронные системы с возможностью отмены задач, получения результатов и обработки ошибок.

7. Пример использования Callable с возвращаемыми результатами и исключениями

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();
        }
    }
}

#Java #Training #Medium #Multithreading #Callable

134 views06:59

Java for Beginner

Продолжаем устранять пробелы в многопоточке Java. Сегодня рассмотрим Semaphore и CountDownLatch.

Semaphore

Semaphore используется для управления доступом к ограниченному ресурсу, который может одновременно использоваться только определенным числом потоков. Это полезно для реализации пула ресурсов, например, подключения к базе данных, файловых дескрипторов и других ограниченных ресурсов.

Основные методы Semaphore

acquire(): Захватывает разрешение (пермит). Если разрешений нет, поток блокируется до тех пор, пока одно из них не станет доступным.
acquire(int permits): Захватывает указанное количество разрешений. Если их недостаточно, поток блокируется.
release(): Освобождает разрешение, увеличивая количество доступных разрешений на 1.
release(int permits): Освобождает указанное количество разрешений.
availablePermits(): Возвращает количество доступных разрешений.
tryAcquire(): Пытается захватить разрешение. Возвращает true, если удалось получить разрешение, иначе false.
tryAcquire(int permits, long timeout, TimeUnit unit): Пытается получить разрешения с указанным временем ожидания.
isFair(): Проверяет, использует ли семафор справедливый порядок захвата разрешений (FIFO).

Типы Semaphore

Несправедливый (non-fair): Потоки получают доступ в произвольном порядке (по умолчанию).
Справедливый (fair): Потоки получают доступ в порядке очереди (FIFO).

Пример использования Semaphore

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();
    }
}

Результат:
В каждый момент времени только 2 потока выполняют свою работу.
Остальные ждут освобождения разрешения.

Нюансы Semaphore

Справедливость (fair vs non-fair):
Несправедливый семафор быстрее, но поток может быть отложен, даже если он ожидает дольше других.
Справедливый семафор обеспечивает порядок очереди, но имеет больше накладных расходов.

Deadlock (взаимная блокировка):
Если поток забывает вызвать release() после acquire(), это приведет к "утечке" разрешений.

Пул ресурсов:
Часто используется для ограничения числа потоков, работающих с одним и тем же ресурсом.

#Java #Training #Multithreading #Semaphore

180 views06:59

Java for Beginner

CountDownLatch

CountDownLatch используется для обеспечения синхронизации между потоками, позволяя одному или нескольким потокам ждать завершения операций в других потоках.

Основные методы CountDownLatch

await(): Блокирует поток до тех пор, пока счетчик не станет равен 0.
countDown(): Уменьшает значение счетчика на 1.
getCount(): Возвращает текущее значение счетчика.
await(long timeout, TimeUnit unit): Ждет заданное время. Если счетчик не достигает 0 за указанное время, поток продолжит выполнение.

Пример использования CountDownLatch

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

Результат:
Основной поток будет ждать завершения всех 3 задач.
После выполнения всех потоков (latch.countDown() вызывается 3 раза), основной поток продолжит выполнение.

Нюансы CountDownLatch

Одноразовый:
CountDownLatch нельзя сбросить или переиспользовать. Если нужно использовать его несколько раз, рассмотрите использование CyclicBarrier.

Потокобезопасность:
Все методы потокобезопасны и могут использоваться несколькими потоками одновременно.

Применение:
Инициализация или подготовка перед началом основной работы.
Ожидание завершения группы задач.

Когда использовать Semaphore или CountDownLatch?

Используйте Semaphore, если нужно управлять доступом к ограниченным ресурсам (например, пул соединений).
Используйте CountDownLatch, если потоки должны дождаться выполнения определенного количества задач, прежде чем продолжить выполнение.

Реальные примеры

Semaphore: Ограничение количества одновременных соединений

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: Ожидание завершения загрузки данных

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

#Java #Training #Multithreading #CountDownLatch

156 views06:59

About

Blog

Apps

Platform