Page History

Future(미래)와 PromicePromise(약속)은 JAVA 비동기처리에 있어서 중요한 개념입니다.

미래에는 블록킹이 없기때문에 어느시점 사용가능 해지는 사용가능한 함수의 결과(성공또는 실패등을)

를 담을수 있는 용기라고 보면 됩니다.

Scala에서 지원하는 키워드이지만 일반적으로 결과에대한

비동기적인 핸들이라고 보면 되겠으며 C#/JAVA에서도 유사한 모델을 가지고 있습니다.

이것은 AKKA의 요소가아닌 기존 개발 플랫폼의 비동기처리 요소로

나중에 Actor, Akka Stream등과 연동되는 중요한 요소로 사용이 될수 있습니다.

관련 참고 원문: 이러한 컨셉은 Java(8)/.net(4.5)에서도 지원을 합니다.

• https://docs.scala-lang.org/overviews/core/futures.html (scala)
• http://docs.scala-lang.org/sips/completed/futures-promises.html ( scala )
• https://msdn.microsoft.com/en-us/library/ff963556.aspx (.net)

• http://www.baeldung.com/java-completablefuture (java)

var result = await actor1.Ask("hello");

final FiniteDuration duration = Duration.create(20, TimeUnit.SECONDS); 
Future<Object> future = Patterns.ask(asyncWorker,
  RequestWorkerMsgType.CHECK_FUTURE_STATE, new Timeout(duration)); 
ResponseOnSingeRequest response = (ResponseOnSingeRequest)Await.result(future, duration);

import java.util.concurrent.CompletableFuture;
 
 
//선언부
@FunctionalInterface
interface FuncB {
    public int calc(int a, int b);
}
  
@FunctionalInterface
interface FuncA {
    public int calc(int a);
}
 
//사용부
FuncA F1 = (int a) -> a+1;
FuncA F2 = (int a) -> a+1;
FuncA F3 = (int a) -> a+1;
FuncB F4 = (int a,int b) -> a+b;
              
Integer input=1;
CompletableFuture<Integer> futureB
    
    = CompletableFuture.supplyAsync(() -> input+1F1.calc(1) );
 
CompletableFuture<Integer> futureC futureD
        
= CompletableFuture.supplyAsync(() -> input+1+2F3.calc(F2.calc(1))  );
 
CompletableFuture<Void> combinedFuture
 
       = CompletableFuture.allOf(futureB, futureC);

combinedFuture.get();

Integer result, futureD)
        .thenAccept( r-> {
            // 최종 연산로직을 비동기로 처리한 케이스
            Integer value1 = futureB.join();
            Integer value2 = futureD.join();
            log( String.format("async result:%d", value1+value2 ));
        });
combinedFuture.join(); //연산을 비동기적으로 시작하려면 join명령을 사용합니다.
// 최종 연산로직을 동기처리로 변환한 예
combinedFuture.get();   //동기처리로 진행하려면 get을 사용합니다.
Integer sresult = futureB.get() + futureCfutureD.get();		
System.out.println(result
log( String.format("sync result:%d",sresult) );

public class ReActor : ReceiveActor
{
  private ILoggingAdapter log = Context.GetLogger();

  public ReActor()
  {
      string myPath = Self.Path.ToString();

      Receive<string>(message => {
          Handle(message);                
      });

      Receive<DelayReply>(message => {
          Handle(message);
      });
  }

  public void Handle(string str)      //InMessage
  {
      Task.Run(async () =>
      {
          await Task.Delay(1000); //어떠한 값을 기다림동기적함수를 호출하여 지연시키지만 액터는 멈추지 않습니다.
          DelayReply reply = new DelayReply();
          reply.message = str;
          return reply;
      }).PipeTo(Self);
  }

  public void Handle(DelayReply data) //Out
  {
      string logtrace = string.Format("I'am {0} RE:{1}", Self.Path, data.message);
      log.Info(data.message);
      Sender.Tell(data);
  }
          
}