Як створити кілька потоків для кожного елемента запиту

Я намагаюся обробити код нижче, використовуючи багатопотоковість на рівні замовлення.

List<String> orders = Arrays.asList("order1", "order2", 
                   "order3", "order4", "order1");

Поточне послідовне виконання:

orders.stream().forEach(order -> {
    rules.forEach(rule -> {
        finalList.add(beanMapper.getBean(rule)
                .applyRule(createTemplate.apply(getMetaData.apply(rule), command),
                           order));
    });
});

Я спробував використовувати:

orders.parallelStream().forEach(order -> {}} // code snippet.

Але це змінює правила.forEach (правило -> {}} порядок.

Наприклад:
Введення:

 List<String> orders = Arrays.asList("order1", "order2", 
                         "order3", "order4", "order1");
 List<String> rules = Arrays.asList("rule1", "rule2", "rule3");

Очікуваний вихід:

order1 with rule1, rule2, rule3
order2 with rule1, rule2, rule3

Фактичний вихід з parallelStream():

order1 with rule3, rule1, rule2
order1 with rule2, rule1, rule3

Мене не турбує порядок наказів , але мене турбує е-порядок правил . Замовлення можуть оброблятись у будь-якому порядку, але правила повинні виконуватись у тому самому порядку для кожного замовлення.

Будь ласка, допоможіть.

Ви можете використовувати:

orders.stream().parallel().forEachOrdered(// Your rules logic goes here. )

ForEachOrряд гарантує збереження порядку Потоку.

Тож для довідки:

orders.stream().parallel().forEachOrdered( order -> {

            rules.stream().parallel().forEachOrdered ( rule -> {

                 System.out.println( " Order : " + order + " rule :" + rule);
            });

        });

Примітка. Хоча ми можемо це зробити, за виконанням слід уважно спостерігати, бо пареллізм і порядок не одружуються дуже добре!

Вихідні дані

 Order : order1 rule :rule1
 Order : order1 rule :rule2
 Order : order1 rule :rule3
 Order : order2 rule :rule1
 Order : order2 rule :rule2
 Order : order2 rule :rule3
 Order : order3 rule :rule1
 Order : order3 rule :rule2
 Order : order3 rule :rule3
 Order : order4 rule :rule1
 Order : order4 rule :rule2
 Order : order4 rule :rule3
 Order : order1 rule :rule1
 Order : order1 rule :rule2
 Order : order1 rule :rule3

Ви додаєте елементи в finalListрізні потоки одночасно. Це викликає змішування результатів застосування правил до різних замовлень (правила не групуються за їхніми наказами).

Ви можете виправити це, створивши тимчасовий список для кожного, orderа потім синхронно об'єднавши всі тимчасові списки в finalList.

Ось як це можна зробити за допомогою Stream-API (Java 9+):

List<AppliedRule> finalList = orders.parallelStream().map(order ->
        rules.stream().map(rule -> applyRule(order, rule)).collect(Collectors.toList())
).collect(Collectors.flatMapping(Collection::stream, Collectors.toList()));

Примітка: Collectors.flatMapping()тут використовується замість простого flatMapсинхронного виконання плоского відображення під час збору потоку.

Аналог Java 8:

List<AppliedRule> finalList = orders.parallelStream().map(order ->
        rules.stream().map(rule -> applyRule(order, rule)).collect(Collectors.toList())
).collect(Collectors.toList())
        .stream()
        .flatMap(Collection::stream)
        .collect(Collectors.toList());

Чи буде це працювати?

final int rulesSize = rules.size();
AtomicInteger atomicInteger = new AtomicInteger(0);
orders.stream().parallel().forEach(order -> {
    IntStream.range(0, rulesSize).parallel().forEach( i -> {
        synchronized (atomicInteger) {
            System.out.println(" Order : " + order + " rule :" + rules.get(atomicInteger.getAndIncrement() % rulesSize));
        }
    });
});

Вихідні дані

 Order : order1 rule :rule1
 Order : order4 rule :rule2
 Order : order1 rule :rule3
 Order : order3 rule :rule1
 Order : order3 rule :rule2
 Order : order3 rule :rule3
 Order : order2 rule :rule1
 Order : order2 rule :rule2
 Order : order2 rule :rule3
 Order : order1 rule :rule1
 Order : order1 rule :rule2
 Order : order4 rule :rule3
 Order : order1 rule :rule1
 Order : order4 rule :rule2
 Order : order1 rule :rule3

Порядок замовлень може бути будь-яким, але порядок правил не повинен змінюватися. Також для певного правила замовлення слід надходити в групі.

Якщо це так, немає місця для фактичного паралелізму.

Коли

order1-rule1
order1-rule2
order2-rule1
order2-rule2

і

order2-rule1
order2-rule2
order1-rule1
order1-rule2

є єдиними дійсними пробіжками для 2 замовлень та 2 правил,
і

order1-rule1
order2-rule1
order1-rule2
order2-rule2

вважається недійсним, тобто не паралелізм, а просто рандомізація orders, імовірно, без виграшу. Якщо вам "нудно", коли ви order1прийдете спочатку весь час, ви можете перетасувати список, але це все:

public static void main (String[] args) throws java.lang.Exception
{
    List<String> orders = Arrays.asList("order1", "order2", "order3", "order4");
    List<String> rules = Arrays.asList("rule1", "rule2", "rule3");
    Collections.shuffle(orders);
    orders.forEach(order->{
        rules.forEach(rule->{
            System.out.println(order+"-"+rule);
        });
    });
}

Навіть не потрібно потокове передавання, просто дві вкладені петлі. Тест: https://ideone.com/qI3dqd

order2-rule1
order2-rule2
order2-rule3
order4-rule1
order4-rule2
order4-rule3
order1-rule1
order1-rule2
order1-rule3
order3-rule1
order3-rule2
order3-rule3

Але це змінює правила.forEach (правило -> {}} порядок.

Ні, це не є. В orderи можуть перекривати один одного, але порядок ruleз для кожного замовлення зберігаються. Чому б непаралель forEachробив щось інше?

Приклад коду:

public static void main (String[] args) throws java.lang.Exception
{
    List<String> orders = Arrays.asList("order1", "order2", "order3", "order4");
    List<String> rules = Arrays.asList("rule1", "rule2", "rule3");
    orders.stream().parallel().forEach(order->{
        rules.forEach(rule->{
            System.out.println(order+"-"+rule);
        });
    });
}

Тест: https://ideone.com/95Cybg
Приклад виведення:

order2-rule1
order2-rule2
order2-rule3
order1-rule1
order1-rule2
order1-rule3
order4-rule1
order4-rule2
order4-rule3
order3-rule1
order3-rule2
order3-rule3

Порядок orders змішаний, але rules завжди 1-2-3. Я думаю, що ваш результат просто приховав пар (насправді ви не показали, як це генерується).

Звичайно, його можна продовжити з деякими затримками, тому обробка orders фактично перекриється:

public static void delay(){
    try{
        Thread.sleep(ThreadLocalRandom.current().nextInt(100,300));
    }catch(Exception ex){}
}

public static void main (String[] args) throws java.lang.Exception
{
    List<String> orders = Arrays.asList("order1", "order2", "order3", "order4");
    List<String> rules = Arrays.asList("rule1", "rule2", "rule3");
    orders.stream().parallel().forEach(order->{
        rules.forEach(rule->{
            delay();
            System.out.println(order+"-"+rule);
        });
    });
}

Тест: https://ideone.com/cSFaqS
Приклад виведення:

order3-rule1
order2-rule1
order2-rule2
order3-rule2
order3-rule3
order2-rule3
order1-rule1
order4-rule1
order1-rule2
order4-rule2
order4-rule3
order1-rule3

Це може бути те, що ви бачили, тільки без orderxчастини. З orderвидимим s можна відстежити, що ruleпродовжують надходити як 1-2-3, заorder . Також ваш список прикладів містив order1двічі, що точно не допомогло побачити, що відбувається.

Якщо ви не проти спробувати бібліотеку сторонніх розробників. Ось зразок з моєю бібліотекою: abacus-util

StreamEx.of(orders).parallelStream().forEach(order -> {}}

Ви навіть можете вказати номер потоку:

StreamEx.of(orders).parallelStream(maxThreadNum).forEach(order -> {}}

Порядок ruleволі буде дотримано .

До речі, оскільки він знаходиться в паралельному потоці, фрагмент коду, ...finalList.add(...швидше за все, не буде працювати. Я думаю, що краще зібрати результат для переліку:

StreamEx.of(orders).parallelStream().map/flatMap(order -> {...}}.toList()

це також можливо, навіть якщо ви хочете orderчомусь зберегти порядок :

StreamEx.of(orders).indexed().parallelStream()
      .map/flatMap(order -> {...}}.sortedBy(...index).toList()