Jdk8 de corriente ¿Qué nuevas (3)

Comparar la eficiencia de corrientes de flujo en serie y paralelo:

/ ** 
 * @author GTR 
 * @create 2020/3/31 
 * / 
público  de clase Demo07Parallel { 

    privado  estáticas  finales  int veces = 500000000 ;
    larga comenzar; 
    @Before 
    pública  vacío init () { 
        empezar = System.currentTimeMillis (); 
    } 

    @After 
    pública  vacío Destory () {
         a largo final = System.currentTimeMillis (); 
        System.out.println ( "消耗时间:" + (final - inicial)); 
    } 

    //Paralelo Corriente: Tiempo de consumo: 431 
    @test
     pública  vacío testParallelStream () { 
        LongStream.rangeClosed ( .parallel () al reducir (0 0, Times.) , Long :: SUM); 
    } 

    // serie Corriente: Consumo de tiempo: 623 
    @test
     pública  vacío testStream () {
         // obtener 500.000.000 números y resumió 
        LongStream.rangeClosed .reduce (0, Times) (0 , Long :: SUM); 
    } 
}

Podemos ver la eficiencia parallelStream es el más alto.
Corriente de proceso paralelo de procesamiento se divide y vencerás, que es una gran tarea en varias tareas más pequeñas, cada una de las cuales representa una tarea está en funcionamiento.

Los siguientes experimentos específicos para hacerlo:

@Test
     público  void test0Serial () {
         largo count = Stream.of (4, 5, 3, 9, 1, 2, 6 ) 
                .Filter (s -> { 
                    System.out.println (Thread.currentThread () +", s = "+ s);
                     retorno  verdadera ; 
                }) 
                .count (); 
        System.out.println ( "count =" + count); 
    }

 corrientes paralelas:

@Test
     público  void test0Parallel () {
         larga COUNT = Stream.of (. 4 ,. 5 ,. 3 ,. 9 ,. 1, 2 ,. 6 ) 
                .parallel) ( // tiempo a fluir en corrientes concurrentes, la corriente de procesamiento antes de ir a la 
                .Filter (S -> { 
                    System.out.println (Thread.currentThread () + "S =" + S);
                     retorno  a la verdadera ; 
                }) 
                .count (); 
        System.out.println ( "COUNT =" + COUNT); 
    }

Obtener corrientes paralelas de dos maneras:
la corriente de acceso paralelo directo: parallelStream ()
de flujo en serie en corrientes paralelas: Paralelo ()

Paralelas de hilo de seguridad cuestiones corrientes:

@Test
     pública  vacío parallelStreamNotice () { 
        ArrayList <Integer> list = nuevo ArrayList <> (); 
        IntStream.rangeClosed ( 1, 1000 ) 
                .parallel () 
                .forEach (i -> { 
                    list.add (i); 
                }); 
        System.out.println ( "list =" + list.size ()); 
}

@Test
     pública  vacío parallelStreamNotice () { 
        ArrayList <Integer> = Lista nuevo nuevo ArrayList <> ();
 //         IntStream.rangeClosed (. 1, 1000)
 //                 .parallel ()
 //                 .forEach (I -> {
 //                     Lista. Añadir (I);
 //                 });
 //         System.out.println ( "Lista =" + list.size ()); 

        // programa hilo de seguridad parallelStream resolver: bloque síncrono 
        objeto obj = new new Object ( ); 
        IntStream.rangeClosed ( 1, 1000. ) 
                .parallel ()
                .forEach (i  ->{
                     sincronizada (obj) { 
                        list.add (i); 
                    } 
                }); 
        System.out.println ( "list =" + list.size ()); 
}

 

 

 // parallelStream hilo de seguridad 
    @test
     pública  vacío parallelStreamNotice () { 
        ArrayList <Integer> = Lista nuevo nuevo ArrayList <> ();
 //         (. 1, 1000) IntStream.rangeClosed
 //                 .parallel ()
 //                 .forEach (I - > {
 //                     List.add (I);
 //                 });
 //         System.out.println ( "Lista =" + list.size ()); 

        // programa hilo de seguridad parallelStream resolver: bloque síncrono
 //         Object obj = new new Object ();
 //         (. 1, 1000) IntStream.rangeClosed
 //                .parallel ()
 //                 .forEach (I -> {
 //                     el sincronizada (obj) {
 //                         List.add (I);
 //                     }
 //                 }); 

        // resolver parallelStream Opción II hilo de seguridad: seguro para subprocesos establecer 
         el vector <Integer> = V nuevo nuevo el Vector (); 
        List <Integer> = synchronizedList la Collections.synchronizedList (Lista); 
        IntStream.rangeClosed ( 1, 1000. ) 
                .parallel () 
                .forEach (I -> { 
        el Sistema. out.println ( 
                    synchronizedList.add (I );
                }); "list =" + synchronizedList.size ()); 
}

 // parallelStream线程安全问题
    @test
     pública  vacío parallelStreamNotice () { 

        Lista <entero> = cobro revertido IntStream.rangeClosed (1, 1000 ) 
                .parallel () 
                .boxed () 
                .collect (Collectors.toList ()); 
        System.out.println ( "collect.size =" + collect.size ()); 
    }