Как можно организовать обмен данными между двумя потоками в Java?

Обмен данными между потоками в Java можно организовать следующими способами:

• Общие переменные с синхронизацией: Потоки используют общие переменные, доступ к которым синхронизируется с помощью ключевого слова synchronized, блокировок (Lock из java.util.concurrent.locks) или атомарных переменных (Atomic из java.util.concurrent.atomic).
• Конвейеры данных (Piped Streams): Связанные потоки ввода/вывода (PipedInputStream и PipedOutputStream) позволяют одному потоку записывать данные, а другому - их читать.

  // Использование Piped Streams
  try {
      PipedOutputStream pout = new PipedOutputStream();
      PipedInputStream pin = new PipedInputStream(pout);
  
      // Поток 1: запись
      new Thread(() -> {
          try {
              pout.write("Hello from thread 1".getBytes());
              pout.close();
          } catch (Exception e) {
              e.printStackTrace();
          }
      }).start();
  
      // Поток 2: чтение
      new Thread(() -> {
          try {
              int data;
              while ((data = pin.read()) != -1) {
                  System.out.print((char) data);
              }
              pin.close();
          } catch (Exception e) {
              e.printStackTrace();
          }
      }).start();
  } catch (Exception e) {
      e.printStackTrace();
  }
  

• Очереди (Queues): Использование потокобезопасных коллекций, таких как BlockingQueue (например, ArrayBlockingQueue, LinkedBlockingQueue), позволяет одному потоку помещать элементы в очередь, а другому - извлекать их.

  import java.util.concurrent.BlockingQueue;
  import java.util.concurrent.LinkedBlockingQueue;
  
  // Использование BlockingQueue
  BlockingQueue<String> queue = new LinkedBlockingQueue<>();
  
  // Производитель
  new Thread(() -> {
      try {
          queue.put("Message 1");
          queue.put("Message 2");
      } catch (InterruptedException e) {
          Thread.currentThread().interrupt();
      }
  }).start();
  
  // Потребитель
  new Thread(() -> {
      try {
          System.out.println(queue.take());
          System.out.println(queue.take());
      } catch (InterruptedException e) {
          Thread.currentThread().interrupt();
      }
  }).start();
  

• Механизмы wait(), notify(), notifyAll(): Используются для синхронизации потоков на основе мониторов объекта. Один поток вызывает wait() для ожидания условия, другой поток вызывает notify() или notifyAll() для уведомления ожидающих потоков об изменении условия.

  // Использование wait/notify
  class Data {
      private String message;
      private boolean empty = true;
  
      public synchronized String read() {
          while (empty) {
              try {
                  wait(); // Ожидаем данных
              } catch (InterruptedException e) {
                  Thread.currentThread().interrupt();
              }
          }
          empty = true;
          notifyAll(); // Уведомляем о возможности записи
          return message;
      }
  
      public synchronized void write(String message) {
          while (!empty) {
              try {
                  wait(); // Ожидаем, пока прочитают предыдущие данные
              } catch (InterruptedException e) {
                  Thread.currentThread().interrupt();
              }
          }
          empty = false;
          this.message = message;
          notifyAll(); // Уведомляем о наличии новых данных
      }
  }
  

• CompletableFuture: Позволяет создавать асинхронные вычисления и объединять их результаты, обеспечивая обмен данными через возвращаемые значения и обработчики завершения.
• Exchanger: Позволяет двум потокам обменяться объектами в точке синхронизации.

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