Java Thread: пример приложения в реальном времени

Question

Мне задали вопрос в интервью, где у меня есть список, доступный в основном методе, и мне сказали, что для каждого элемента в списке есть какая-то операция, как бы я мог добиться этого с помощью концепции потоков. Рассмотрим следующую ситуацию: У меня есть список целых чисел. Мне нужно распечатать все значения из списка. Можно ли это сделать с помощью концепции потоков, где у меня есть несколько потоков, выполняемых на каждом элементе в списке, и где каждый поток используется для печати значения, а не одного потока, который печатает все значения? Я не пытаюсь изменить какое-либо значение в списке.

Answer 1

Я надеюсь, что вы ищете что-то вроде этого:

public class MaltiThreadExample { 

    /** 
    * @param args the command line arguments 
    */ 
    public static void main(String[] args) { 
     List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3)); 

     for (int i : list) { 
      Thread th = new Thread() { 
       @Override 
       public void run() { 
        System.out.println(i); 
       } 
      }; 
      th.start(); 
     } 
    } 

} 

Выход для одного исполнения:

run: 
3 
1 
2 
BUILD SUCCESSFUL (total time: 0 seconds) 

Answer 2

Да, это типичный производитель-потребитель парадигма:

Представьте класс Runnable, который получает параметр Iterator как параметр и ждет определенного монитора, а затем потребляет один элемент из итератора, nd последний уведомляет о том же мониторе. Циклы, в то время как итератор имеет больше элементов.

Для этого будет достаточно создать список чисел, создать потоки потребителей, передающие им итератор списка, и запустить их.

Answer 3

Код, указанный ниже, не проверен вообще. Это просто то, что приходит в голову. Последняя реализация с использованием parallelStream() может быть тем, что вы ищете.

public class DemoApplication { 

    public static void main(String[] args) { 
     final List<Integer> myIntegerList = Arrays.asList(1, 2, 3); 

     // Good old for-each-loop 
     for (Integer item : myIntegerList) { 
      System.out.print(item); 
     } 

     // Java 8 forEach with Consumer 
     final Consumer<Integer> consumer = new Consumer<Integer>() { 
      @Override 
      public void accept(Integer item) { 
       System.out.print(item); 
      } 
     }; 

     myIntegerList.forEach(consumer); 

     // Java 8 forEach with Lambda 
     myIntegerList.forEach((item) -> System.out.print(item)); 

     // Java 8 forEach on parallelStream with Lambda 
     myIntegerList.parallelStream().forEach((item) -> System.out.print(item)); 
    } 
} 

Answer 4

я пытаюсь понять преимущество потоков.

Есть в основном две причины для использования нескольких потоков в программе:

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

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

Программы, которая имеет один поток для каждого различного вида событие часто намного чище. То есть легче понять, проще изменить и т. Д. Каждый поток цикла ожидает только одного вида события, а его состояние (если оно есть) может храниться в локальных переменных или его состояние может быть неявным (т. Е. зависит от того, какая функция имеет поток в любой момент времени).

(2) Многопроцессорная обработка (a.k.a., «параллельная обработка», «параллельное программирование», ...): Использование рабочих потоков для выполнения фоновых вычислений, вероятно, является наиболее распространенной моделью многопроцессорной обработки, используемой в данный момент времени.

Многопоточность - это самый низкий уровень всех моделей многопроцессорности, что означает: (а) это труднее всего понять, но (б) оно является наиболее универсальным.