java8Uso de frameworks forkjoin y optional

Flujo paralelo y flujo secuencial

El flujo paralelo es dividir un contenido en varios bloques de datos y procesar cada bloque de datos con diferentes hilos.

java 8 Se ha optimizado la operación paralela, por lo que podemos operar con datos paralelos de manera fácil. El API de Stream puede cambiar declarativamente entre flujos paralelos y secuenciales mediante parallel () y sequential ().

Conocer Fork/El framework Join

Fork/El framework Join: es dividir una gran tarea, en caso necesario, en varias tareas pequeñas (dividir hasta que no se pueda dividir más), y luego unir los resultados de la ejecución de cada una de estas tareas pequeñas.

Fork/La diferencia entre el framework Join y el pool de hilos tradicional:

Se utiliza el modelo de "robo de trabajo" (work-):

Al ejecutar una nueva tarea, puede dividirla en tareas más pequeñas para ejecutarlas, y luego agregar estas tareas pequeñas a la cola de hilos, antes de robar una de ellas de la cola de un hilo aleatorio y colocarla en su propia cola.

En comparación con la implementación común del pool de hilos, fork/Las ventajas del framework join se manifiestan en la forma en que maneja las tareas que contiene. En un pool de hilos común, si un hilo no puede continuar ejecutando una tarea por alguna razón, ese hilo se encontrará en estado de espera. Mientras que en fork/En la implementación del framework join, si algún subproblema no puede continuar debido a que espera la finalización de otro subproblema, el hilo encargado de manejar ese subproblema buscará activamente otros subproblemas no ejecutados para ejecutarlos. Este enfoque reduce el tiempo de espera de los hilos y mejora el rendimiento.

import java.time.Duration;
import java.time.Instant;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;
import java.util.stream.LongStream;
public class TestForkJoin {
  public static void main(String[] xx){
  }
  private static void test1(){
  	Instant start=Instant.now();
    ForkJoinPool pool=new ForkJoinPool();
    ForkJoinTask<Long> task = new ForkJoinCalculate(0L, 10000000000L);
    long sum = pool.invoke(task);
    System.out.println(sum);
    Instant end=Instant.now();
    System.out.println("消耗时间"+Duration.between(start, end).toMillis()+"ms");//消耗时间3409ms
  }
  private static void test2(){
    Instant start=Instant.now();
    Long sum = LongStream.rangeClosed(0L, 10000L)
               .parallel()
               .reduce(0,Long::sum);
    System.out.println(sum);
    Instant end=Instant.now();
    System.out.println("消耗时间" + Duration.between(start, end).toMillis()+"ms");//消耗时间2418ms
  } 
}
class ForkJoinCalculate extends RecursiveTask<Long>{
  private static final long serialVersionUID = 1234567890L;//序列号
  private long start;
  private long end;
  private static final long THRESHOLD=2500000000L;//Valor crítico
  public ForkJoinCalculate(long start,long end) {
    this.start=start;
    this.end=end;
  }
  @Override
  protected Long compute() {
    long length = end - start;
    if(length <= THRESHOLD){
      long sum=0;
      for(long i = start; i <= end; i++{
        sum += i;
      }
      return sum;
    } else {
      long middle = (start+end);/2;
      ForkJoinCalculate left = new ForkJoinCalculate(start, middle);
      left.fork();
      ForkJoinCalculate right=new ForkJoinCalculate(middle+1, end);
      right.fork();
      return left.join(); + right.join();
    }
  }
}

Clase Optional

La clase Optional< T>(java.util.Optional) es una clase contenedora que representa si un valor existe o no.

Antes se utilizaba null para representar la inexistencia de un valor, ahora Optional puede expresar esta idea de manera mejor y evitar la excepción de puntero nulo.

Métodos comunes:

Optional.of(T t): Crea una instancia de Optional

Optional.empty(): Crea una instancia de Optional vacía

Optional.ofNullable(T t): Si t no es null, crea una instancia de Optional, de lo contrario crea una instancia vacía

isPresent(): Determina si contiene un valor

orElse(T t): Si el objeto de llamada contiene un valor, devuelve ese valor, de lo contrario devuelve t

orElseGet(Supplier s): Si el objeto de llamada contiene un valor, devuelve ese valor, de lo contrario devuelve el valor obtenido por s

map(Function f): Si hay un valor, se procesa y se devuelve el Optional procesado, de lo contrario se devuelve Optional.empty()

flatMap(Function mapper): Similar a map, requiere que el valor de retorno sea Optional

public class OptionalTest1 {}}
  public static void main(String[] args){
  	String s = new String("Ha");
//  	Optional<String> op = Optional.of(null);
//  	
//  	String s1 = op.get();
//  	System.out.println(s1);
//  	Optional<String> op1 = Optional.empty();
//  	String s1 = op1.get();
//  	System.out.println(s1);  
  	Optional<String> op1 = Optional.ofNullable(null);
//  	System.out.println(op1.isPresent());
//  	System.out.println(op1.orElse(new String("Google")));
  	//System.out.println(op1.orElseGet(() -> new String("Ali")));
  	Optional<String> op2 = op1.map((x) -> x.toLowerCase());
  	String s2 = op2.get();
  	System.out.println(s2);  	
  }
}

@Test
  public void test5(){
    Man man=new Man();
    String name=getGodnessName(man);
    System.out.println(name);
  }
  //Requisito: Obtener el nombre de la diosa ideal de un hombre
  public String getGodnessName(Man man){
    if(man!=null){
      Godness g=man.getGod();
      if(g!=null){
        return g.getName();
      }
    }
    return "Maestro Cang";
  }
  //Aplicación de la clase de entidad Optional
  @Test
  public void test6(){
    Optional<Godness> godness=Optional.ofNullable(new Godness("Lin Zhiqing"));
    Optional<NewMan> op=Optional.ofNullable(new NewMan(godness));
    String name=getGodnessName2(op);
    System.out.println(name);
  }
  public String getGodnessName2(Optional<NewMan> man){
    return man.orElse(new NewMan())
         .getGodness()
         .orElse(new Godness("Maestro Cang"))
         .getName();
  }
//Atención: Optional no puede ser serializado
public class NewMan {
  private Optional<Godness> godness = Optional.empty();
  private Godness god;
  public Optional<Godness> getGod(){
    return Optional.of(god);
  }
  public NewMan() {
  }
  public NewMan(Optional<Godness> godness) {
    this.godness = godness;
  }
  public Optional<Godness> getGodness() {
    return godness;
  }
  public void setGodness(Optional<Godness> godness) {
    this.godness = godness;
  }
  @Override
  public String toString() {
    return "NewMan [godness=" + godness + "]";
  }
}

Aquí está lo que hemos organizado para usted de java8Todo el contenido de experiencia en el uso de los marcos forkjoin y optional, si aún tienen alguna duda al aprender, pueden discutir en la sección de comentarios a continuación.

Declaración: Este artículo se ha recopilado de la red, pertenece al propietario original, el contenido se ha contribuido y cargado de manera autónoma por los usuarios de Internet, este sitio web no posee los derechos de propiedad, no se ha procesado editorialmente por humanos y no asume la responsabilidad de las responsabilidades legales relacionadas. Si encuentra contenido sospechoso de infracción de derechos de autor, por favor envíe un correo electrónico a: notice#w3Declaración: El contenido de este artículo se obtiene de la red, pertenece al propietario original, el contenido se contribuye y carga de manera autónoma por los usuarios de Internet, este sitio web no posee los derechos de propiedad, no se ha realizado un procesamiento editorial humano y no asume la responsabilidad de las responsabilidades legales relacionadas. Si encuentra contenido sospechoso de infracción de derechos de autor, por favor envíe un correo electrónico a: notice#w