Использовали ли вы java.util.concurrent в Java 5?

Да, широко использовал.

java.util.concurrent предложил мощные инструменты для создания конкурентных приложений в Java 5, существенно упростив работу с потоками по сравнению с более низкоуровневыми механизмами.

Основные компоненты java.util.concurrent в Java 5, которые активно применялись:

• Исполнители (Executors): Управление пулами потоков. Позволяли отделить задачи от их выполнения, снижая накладные расходы на создание/уничтожение потоков.

  // Пример использования ExecutorService
  ExecutorService executor = Executors.newFixedThreadPool(10);
  executor.submit(() -> {
      // Код задачи, выполняющейся в потоке из пула
      System.out.println("Task executed by thread: " + Thread.currentThread().getName());
  });
  executor.shutdown(); // Важно завершить работу пула после использования
  

• Конкурентные коллекции (Concurrent Collections): Потокобезопасные коллекции, такие как ConcurrentHashMap, CopyOnWriteArrayList. Обеспечивали эффективную работу с данными в многопоточной среде без необходимости явной синхронизации в большинстве случаев.

  // Пример использования ConcurrentHashMap
  ConcurrentMap<String, Integer> map = new ConcurrentHashMap<>();
  map.put("key1", 1);
  map.put("key2", 2);
  // Добавление или обновление атомарно
  map.computeIfAbsent("key3", k -> 3);
  

• Синхронизаторы (Synchronizers): Механизмы для управления взаимодействием между потоками, например:
  • Semaphore: Ограничение количества потоков, одновременно получающих доступ к ресурсу.
  • CountDownLatch: Позволяет одному или нескольким потокам ждать завершения работы других потоков.
  • CyclicBarrier: Позволяет группе потоков ожидать друг друга в определенной точке барьера.

  // Пример использования CountDownLatch
  int numberOfWorkers = 3;
  CountDownLatch latch = new CountDownLatch(numberOfWorkers);
  
  for (int i = 0; i < numberOfWorkers; i++) {
      new Thread(() -> {
          // Выполнение некоторой работы
          System.out.println("Worker is doing something...");
          latch.countDown(); // Уведомление о завершении работы
      }).start();
  }
  
  try {
      latch.await(); // Ожидание завершения работы всех рабочих
      System.out.println("All workers have finished.");
  } catch (InterruptedException e) {
      Thread.currentThread().interrupt();
  }
  

• Блокировки (Locks): Более гибкая альтернатива встроенным примитивам синхронизации (synchronized). Главным образом, ReentrantLock, который предоставлял дополнительные возможности, такие как неблокирующие попытки получения блокировки и прерываемая блокировка.

  // Пример использования ReentrantLock
  ReentrantLock lock = new ReentrantLock();
  
  public void doSynchronizedWork() {
      lock.lock(); // Получение блокировки
      try {
          // Защищенный код
          System.out.println("Executing synchronized code.");
      } finally {
          lock.unlock(); // Освобождение блокировки
      }
  }
  

Использование java.util.concurrent в Java 5 было ключевым для разработки надежных и производительных многопоточных приложений, обеспечивая более высокий уровень абстракции и уменьшая вероятность распространенных ошибок многопоточности.