feat(parallel-streams): 5 exemplos de streams paralelos

Adição de 5 exemplos sobre Streams paralelos.

Ref. Issue #24

Author: rinaldodev

book/05-java-streams/sections/02-parallel-streams.asc

@@ -10,15 +10,87 @@ Develop code that uses parallel streams, including decomposition operation and r
 Desenvolver código que usa Streams Paralelos, incluindo operação de decomposição e operação de redução em Streams
 --------------------------------------------------
 
-Streams podem ser sequenciais ou paralelos. Os sequencias foram vistos na seção anterior, enquanto os paralelos serão apresentados nesta seção. Streams paralelos são executados por mais de uma Thread, geralmente uma quantidade igual à quantidade de núcleos do processador onde a aplicação está sendo executada. Apesar disso, nem sempre é útil utilizá-los. Seu ganho real é em Streams com grande volumes de dados. Em um Stream pequeno, transformá-lo em paralelo pode até causar uma perda de performance.
+_Streams_ podem ser sequenciais ou paralelos. Os sequencias foram vistos na seção anterior, enquanto os paralelos serão apresentados nesta seção. _Streams_ paralelos são executados por mais de uma _Thread_, geralmente uma quantidade igual à quantidade de núcleos do processador onde a aplicação está sendo executada. Apesar disso, nem sempre é útil utilizá-los. Seu ganho real é em _Streams_ com grande volumes de dados. Em um _Stream_ pequeno, transformá-lo em paralelo pode até causar uma perda de performance.
 
-Ao utilizar qualquer tipo de Stream, é recomendável não executar funções lambdas que causem efeitos colaterais, como mudanças no estado de objetos. Em Streams paralelos essa recomendação é ainda mais forte.
+Ao utilizar qualquer tipo de _Stream_, é recomendável não executar funções lambdas que causem efeitos colaterais, como mudanças no estado de objetos. Em _Streams_ paralelos essa recomendação é ainda mais importante.
+
+. É possível transformar qualquer _Stream_ em paralelo utilizando o método `parallel`.
++
+[source,java,indent=0]
+.{java-package}/parallelstreams/Streams_Parallel.java
+----
+include::{section-java-package}/parallelstreams/Streams_Parallel.java[tag=code]
+----
+
+. É possível criar _Streams_ paralelos diretamente em Coleções através do método `parallelStream`.
++
+[source,java,indent=0]
+.{java-package}/parallelstreams/Streams_ParallelStream.java
+----
+include::{section-java-package}/parallelstreams/Streams_ParallelStream.java[tag=code]
+----
+
+. Ao utilizar a operação `forEach` em um _Stream_ paralelo, a ordem de execução não é garantida.
++
+[source,java,indent=0]
+.{java-package}/parallelstreams/Streams_ParallelForEach.java
+----
+include::{section-java-package}/parallelstreams/Streams_ParallelForEach.java[tag=code]
+----
++
+.Saída no console
+[source,console]
+----
+Sequencial: 
+A
+B
+C
+Paralelo: 
+B
+C
+A
+----
++
+O _Stream_ paralelo poderia ter impresso em qualquer ordem, pois não há nenhuma garantia na ordem em que os elementos serão tratados.
+
+. A operação .forEachOrdered garante que a ordem será mantida mesmo em _Streams_ paralelos.
++
+[source,java,indent=0]
+.{java-package}/parallelstreams/Streams_ParallelForEachOrdered.java
+----
+include::{section-java-package}/parallelstreams/Streams_ParallelForEachOrdered.java[tag=code]
+----
++
+.Saída no console
+[source,console]
+----
+Sequencial: 
+A
+B
+C
+Paralelo: 
+A
+B
+C
+----
+
+. Em coleções com muitos objetos pode haver um ganho considerável de performance.
++
+[source,java,indent=0]
+.{java-package}/parallelstreams/Streams_ParallelPerformance.java
+----
+include::{section-java-package}/parallelstreams/Streams_ParallelPerformance.java[tag=code]
+----
++
+.Saída no console
+[source,console]
+----
+Tempo stream sequencial: 9863
+Tempo stream paralelo: 1479
+----
++
+Perceba que na máquina onde o código foi executado, a execução em paralelo demorou apenas 15% do tempo da execução sequencial. Esse não é um teste minucioso, mas mostra o potencial de _Streams_ paralelos.
 
-. Chamando .parallel em Streams
-. Chamando .parallelStream em Coleções
-. Exemplo de .forEach com e sem paralelo, imprimindo em diferentes
-. Exemplo de .forEachOrdered em streams paralelos, que mantém ordem
-. Exemplo de ganho de performance
 . Evitar expressões lambda que alteram o estado de um objeto. Exemplo de forEachOrdered e um map com operação stateful.
 . Exemplo de findAny com resultados imprevisíveis
 . Utilização de unordered para ganhar performance em findFirst, limit, skip

src/org/j6toj8/streams/parallelstreams/Streams_Parallel.java

@@ -0,0 +1,15 @@
+package org.j6toj8.streams.parallelstreams;
+
+import java.util.Arrays;
+
+public class Streams_Parallel {
+
+  public static void main(String[] args) {
+    // tag::code[]
+    String[] array = new String[] { "A", "B", "C" };
+    Arrays.stream(array)
+      .parallel() // stream transformado em paralelo
+      .forEach(System.out::println); 
+    // end::code[]
+  }
+}

src/org/j6toj8/streams/parallelstreams/Streams_ParallelForEach.java

@@ -0,0 +1,21 @@
+package org.j6toj8.streams.parallelstreams;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class Streams_ParallelForEach {
+
+  public static void main(String[] args) {
+    // tag::code[]
+    List<String> list = Arrays.asList("A", "B", "C");
+
+    System.out.println("Sequencial: ");
+    list.stream() // cria um Stream sequencial
+        .forEach(System.out::println);
+
+    System.out.println("Paralelo: ");
+    list.parallelStream() // cria um Stream paralelo
+        .forEach(System.out::println);
+    // end::code[]
+  }
+}

src/org/j6toj8/streams/parallelstreams/Streams_ParallelForEachOrdered.java

@@ -0,0 +1,21 @@
+package org.j6toj8.streams.parallelstreams;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class Streams_ParallelForEachOrdered {
+
+  public static void main(String[] args) {
+    // tag::code[]
+    List<String> list = Arrays.asList("A", "B", "C");
+
+    System.out.println("Sequencial: ");
+    list.stream() // cria um Stream sequencial
+        .forEachOrdered(System.out::println);
+
+    System.out.println("Paralelo: ");
+    list.parallelStream() // cria um Stream paralelo
+        .forEachOrdered(System.out::println);
+    // end::code[]
+  }
+}

src/org/j6toj8/streams/parallelstreams/Streams_ParallelPerformance.java

@@ -0,0 +1,23 @@
+package org.j6toj8.streams.parallelstreams;
+
+import java.util.stream.IntStream;
+
+public class Streams_ParallelPerformance {
+
+  public static void main(String[] args) {
+    // tag::code[]
+    long inicio = System.currentTimeMillis();
+    IntStream.range(0, Integer.MAX_VALUE) // stream sequencial
+      .mapToDouble(n -> Math.pow(n, 2))
+      .average()
+      .ifPresent(n -> System.out.println("Tempo stream sequencial: " + (System.currentTimeMillis() - inicio)));
+    
+    long inicio2 = System.currentTimeMillis();
+    IntStream.range(0, Integer.MAX_VALUE)
+      .parallel() // stream paralelo
+      .mapToDouble(n -> Math.pow(n, 2))
+      .average()
+      .ifPresent(n -> System.out.println("Tempo stream paralelo: " + (System.currentTimeMillis() - inicio2)));
+    // end::code[]
+  }
+}

src/org/j6toj8/streams/parallelstreams/Streams_ParallelStream.java

@@ -0,0 +1,15 @@
+package org.j6toj8.streams.parallelstreams;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class Streams_ParallelStream {
+
+  public static void main(String[] args) {
+    // tag::code[]
+    List<String> list = Arrays.asList("A", "B", "C");
+    list.parallelStream() // cria um Stream paralelo diretamente
+      .forEach(System.out::println); 
+    // end::code[]
+  }
+}