Início / coding / Perguntas / 78829360
Accepted
happy
Asked: 2024-08-04 01:39:43 +0800 CST

paraleloStream com método de coleta()

  • 772

Estou tentando entender por que há uma diferença quando mudo de y.addAll(x) para x.addAll(y) no trecho de código abaixo:

List<Integer> result = List.of(1, 2)
    .parallelStream() 
    .collect(
        ArrayList::new,
        (x, y) -> x.add(y),
        (x, y) -> y.addAll(x)
    );
System.out.println(result);

Eu sei que quando uso paraleloStream(), há mais de um thread sendo executado por vez.

collect() possui três parâmetros; os dois primeiros parâmetros eu entendo. Com o terceiro parâmetro, sei que x, y são substreams e são ArrayLists, mas não entendo por que os resultados são diferentes em cada caso. Eu esperava que eles fossem iguais.

  • (x, y) -> y.addAll(x) // saída: [1]

  • (x, y) -> x.addAll(y) // saída: [1, 2]

java

2 respostas

  1. Best Answer

    Por que um está correto e o outro não

    Dos Javadocs deStream#collect (especificamente o último parâmetro, ênfase minha):

    combinador - uma função associativa, não interferente e sem estado que aceita dois contêineres de resultados parciais e os mescla, que deve ser compatível com a função acumuladora. A função combinadora deve dobrar os elementos do segundo contêiner de resultados no primeiro contêiner de resultados .

    Da mesma forma, a.addAll(b)adiciona todos os elementos de bto, amas não o contrário. Ele pega informações do parâmetro e modifica o receptor.

    Portanto, o contrato desse método especifica que você deve mesclar o segundo argumento do lambda com o primeiro.

    Se você fizer isso (x, y) -> x.addAll(y), todos os elementos serão adicionados yà xadesão ao contrato. No entanto, (x, y) -> y.addAll(x)você está adicionando-o ao segundo elemento, resultando na ynão adição de elementos aos xquais faltam no resultado.

    O que acontece

    Isso é feito dessa maneira porque os fluxos paralelos dividem o processamento em partes, onde diferentes threads processam partes diferentes. Após o processamento, é necessário mesclar os elementos, o que é feito usando o combinador (a última expressão lambda que você falou). Este combinador precisa ser capaz de combinar dois elementos e o primeiro argumento é então usado para processamento adicional enquanto o segundo é descartado.

    Digamos que temos os números 1 e 2 como no seu exemplo e assumimos que um thread processa um pedaço contendo 1 e o outro thread processa um pedaço contendo 2. Ao coletar, cada thread começa criando um novo ArrayListno ArrayList::newseu código. Os threads então adicionam os elementos de seus pedaços correspondentes à lista, resultando em duas listas com um elemento cada (1 para o primeiro thread e 2 para o outro). Quando ambos os threads terminam, o combinador é chamado para mesclar/combinar os resultados. Com x.addAll(y), adiciona a segunda lista à primeira, que é então retornada produzindo o resultado correto. No entanto, com y.addAll(x), ele adiciona os elementos da primeira lista à segunda lista, mas Java assume que você deseja a primeira lista (pois é isso que você deve modificar), então collect retorna a primeira lista que não contém os elementos processados ​​pelo segundo tópico.

    • 12

  2. Renomeei algumas de suas variáveis ​​para ilustrar um pouco melhor o que está acontecendo.

    List<Integer> result = List.of( 1, 2 )
    .parallelStream() 
    .collect(
        ArrayList::new,
        (thisList,value) -> thisList.add( value ),
        (thisList,theOtherList) -> thisList.addAll( theOtherList )
    );
System.out.println( result );

    O método Stream::collectretorna thisList.

    Quando você altera o terceiro parâmetro da chamada para collect()assim:

    …
(thisList,theOtherList) -> theOtherList.addAll( thisList )
…

    você adiciona o conteúdo de thisListto theOtherListe thisListpermanece inalterado, o que significa que o conteúdo de theOtherListnão é adicionado a ele.

    Que o resultado seja justo 1é coincidência.

    • 6

relate perguntas