リクエストアイテムごとに複数のスレッドを作成する方法

注文レベルでマルチスレッドを使用して以下のコードを処理しようとしています。

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.

しかし、rules.forEach（rule-> {}}の順序を変更しています。

例：
入力：

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

ForEachOrderedは、ストリームの順序を維持することを保証します。

参考までに：

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

ストリーミングも必要ありません。入れ子になった2つのループだけです。テスト：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

しかし、rules.forEach（rule-> {}}の順序を変更しています。

いいえ、違います。ordersが重複してもよいが、順rule各注文のSが保持されます。非パラレル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追跡することができ、可視だrulesは、1-2-3のようにくるごとorder。また、サンプルリストにはorder12度含まれていますが、何が起こっているのかを確認するのに役立ちませんでした。

サードパーティのライブラリを試してもかまわない場合。これが私のライブラリのサンプルです：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()