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("消耗時(shí)間"+Duration.between(start, end).toMillis()+"ms");//消耗時(shí)間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("消耗時(shí)間" + Duration.between(start, end).toMillis()+"ms");//消耗時(shí)間2418ms
  } 
}
class ForkJoinCalculate extends RecursiveTask<Long>{

  private static final long serialVersionUID = 1234567890L;//序列號(hào)

  private long start;
  private long end;
  private static final long THRESHOLD=2500000000L;//臨界值

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

}

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);
  }
  //需求：獲取一個(gè)男人心中女神的名字
  public String getGodnessName(Man man){
    if(man!=null){
      Godness g=man.getGod();
      if(g!=null){
        return g.getName();
      }
    }
    return "蒼老師";
  }
  //運(yùn)用Optional的實(shí)體類(lèi)
  @Test
  public void test6(){
    Optional<Godness> godness=Optional.ofNullable(new Godness("林志玲"));
    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("蒼老師"))
         .getName();
  }
//注意：Optional 不能被序列化
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 + "]";
  }
}