Page History
| Info | ||
|---|---|---|
Future(미래)와 PromicePromise(약속)은 JAVA 비동기처리에 있어서 중요한 개념입니다. 미래에는 블록킹이 없기때문에 어느시점 사용가능한 함수의 결과(성공또는 실패등을) 를 담을수 있는 용기라고 보면 됩니다. Scala에서 지원하는 키워드이지만 일반적으로 결과에대한 비동기적인 핸들이라고 보면 되겠으며 C#/JAVA에서도 유사한 모델을 가지고 있습니다. 이것은 AKKA의 요소가아닌 기존 개발 플랫폼의 비동기처리 요소로 나중에 Actor, Akka Stream등과 연동되는 중요한 요소로 사용이 될수 있습니다. 관련 참고 원문: 이러한 컨셉은 Java(8)/.net(4.5)에서도 지원을 합니다.
|
Future를 사용한 비동기처리 목표
Future와 Promice를 사용하는 목적은, 여러절차가 포함된 복잡한 비동기처리를
콜백헬을 방지하고, 조금더 도식화 할수있는 방법을 제공해줍니다.
콜백헬 예 : http://callbackhell.com/
Future
...
|
Future를 사용한 비동기처리 목표
Future와 Promice를 사용하는 목적은, 여러절차가 포함된 복잡한 비동기처리를
콜백헬을 방지하고, 조금더 도식화 할수있는 방법을 제공해줍니다.
콜백헬 예 : http://callbackhell.com/
Future
| draw.io Diagram | ||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
|
퓨쳐는 읽기전용이며, 퓨쳐에 담긴 값을 외부에서 변경할수 없습니다. 함수 실행이 끝나면
퓨쳐에 성공 또는 실패에 따른 결과가 들어갑니다. 퓨쳐에 담긴 결과는 완료된 다음부터는
바뀌지 않으며, 외부에서 여러번 읽을수 있고 매번 같은 값을 돌려줍니다.
결과가 들어갈 용기가 있으므로 비동기적으로 실행되는 여러 함수들을 쉽게 조합할수가 있습니다.
| Info |
|---|
퓨쳐는 여러함수의 결과가 다음 함수의 입력이되어야할시, 여러 함수가 병렬로 연결되며 나중에 여러 함수의 결과를 조합해야하는 파이프라이닝(pipelining)에 좋은 도구입니다. |
Future Sample-Scala
| draw.io Diagram | ||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
|
| Code Block | ||||||
|---|---|---|---|---|---|---|
| ||||||
var request = EventRequest(ticketNr) //요청을만든다
var response = EventResponse = callEventService(request) //응답이 완료될때까지 기다린다
var event:Event = reponse.event //최종 이벤트값을 읽는다.
val trafficRequest = TrafficRequest{
destination = event.location,
arrivalTime = event.time
)
var trafficResponse = callTrafficService(trafficRequest ) //이벤트값을 가지고 다시 트래픽정보를 요청한다. |
| Code Block | ||||||
|---|---|---|---|---|---|---|
| ||||||
var request = EventRequest(ticketNr) //요청을만든다
val futureRoute : Future[Route] = Future{
callEventService(request).event
}.map{ event =>
val trafficRequest = TrafficRequest{
destination = event.location,
arrivalTime = event.time
)
callTrafficeService(trafficRequest).route //교통 루트를 반환한다.
} |
Future Sample
| Code Block | ||||||
|---|---|---|---|---|---|---|
| ||||||
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;
|
퓨쳐는 읽기전용이며, 퓨쳐에 담긴 값을 외부에서 변경할수 없습니다. 함수 실행이 끝나면
퓨쳐에 성공 또는 실패에 따른 결과가 들어갑니다. 퓨쳐에 담긴 결과는 완료된 다음부터는
바뀌지 않으며, 외부에서 여러번 읽을수 있고 매번 같은 값을 돌려줍니다.
결과가 들어갈 용기가 있으므로 비동기적으로 실행되는 여러 함수들을 쉽게 조합할수가 있습니다.
| Info |
|---|
퓨쳐는 여러함수의 결과가 다음 함수의 입력이되어야할시, 여러 함수가 병렬로 연결되며 나중에 여러 함수의 결과를 조합해야하는 파이프라이닝(pipelining)에 좋은 도구입니다. |
Future Sample-Scala
...
| Code Block | ||||||
|---|---|---|---|---|---|---|
| ||||||
var request = EventRequest(ticketNr) //요청을만든다
var response = EventResponse = callEventService(request) //응답이 완료될때까지 기다린다
var event:Event = reponse.event //최종 이벤트값을 읽는다.
val trafficRequest = TrafficRequest{
destination = event.location,
arrivalTime = event.time
)
var trafficResponse = callTrafficService(trafficRequest ) //이벤트값을 가지고 다시 트래픽정보를 요청한다. |
| Code Block | ||||||
|---|---|---|---|---|---|---|
| ||||||
var request = EventRequest(ticketNr) //요청을만든다
val futureRoute : Future[Route] = Future{
callEventService(request).event
}.map{ event =>
val trafficRequest = TrafficRequest{
destination = event.location,
arrivalTime = event.time
)
callTrafficeService(trafficRequest).route //교통 루트를 반환한다.
} |
Future Sample
| Code Block | ||||||
|---|---|---|---|---|---|---|
| ||||||
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(() -> F1.calc(1) ); CompletableFuture<Integer> futureD = CompletableFuture.supplyAsync(() -> F3.calc(F2.calc(1)) ); CompletableFuture<Void> combinedFuture = CompletableFuture.allOf(futureB, futureD) .thenAccept( r-> { // 최종 연산로직을 비동기로 처리한 케이스 Integer value1 =input=1; CompletableFuture<Integer> futureB.join(); Integer value2 = futureDCompletableFuture.joinsupplyAsync((); -> F1.calc(1) ); CompletableFuture<Integer> futureD log( String.format("async result:%d", value1+value2 )); = CompletableFuture.supplyAsync(() -> F3.calc(F2.calc(1)) ); CompletableFuture<Void> combinedFuture }); combinedFuture.join(); //연산을 비동기적으로 시작하려면 join명령을 사용합니다. // 최종 연산로직을 동기처리로 변환한 예 combinedFuture.get();= CompletableFuture.allOf(futureB, futureD) .thenAccept( r-> { //동기처리로 진행하려면최종 get을 사용합니다. Integer sresult연산로직을 비동기로 처리한 케이스 Integer value1 = futureB.getjoin() +; Integer value2 = futureD.getjoin(); log( String.format("syncasync result:%d",sresult value1+value2 ) ); | ||||||
| Code Block | ||||||
| ||||||
//Labda Func<int, int> F1 = x => x + 1}); combinedFuture.join(); //연산을 비동기적으로 시작하려면 join명령을 사용합니다. // 최종 연산로직을 동기처리로 변환한 예 combinedFuture.get(); //동기처리로 진행하려면 get을 사용합니다. Integer sresult = futureB.get() + futureD.get(); log( String.format("sync result:%d",sresult) ); |
| Code Block | ||||||
|---|---|---|---|---|---|---|
| ||||||
//Labda Func<int, int> F1 = x => x + 1; Func<int, int> F2 = x => x + 1; Func<int, int> F3 = x => x + 1; Func<int, int, int> F4 = delegate ( int x, int y ){ return x + y; }; //Block with task Task<int> futureAFunc<int, int> F2 = x => x + 1; Func<int, int> F3 = x => x + 1; Func<int, int, int> F4 = delegate ( int x, int y ){ return x + y; }; //Block with task Task<int> futureA = Task.Factory.StartNew<int>(() => F1(1)); int c = F2(1); int d = F3(c); int f = F4(futureA.Result, d); Console.WriteLine("ResultA:" + f); //Continuation Tasks var futureB = Task.Factory.StartNew<int>(() => F1(1)); varint futureDc = Task.Factory.StartNew<int>(() =>F2(1); int d = F3(F2(1c))); varint futureFf = Task.Factory.ContinueWhenAll<int, int>( F4(futureA.Result, d); Console.WriteLine("ResultA:" + f); //Continuation Tasks var futureB = Task.Factory.StartNew<int>(() => F1(1)); var futureD = Task.Factory.StartNew<int>(() => F3(F2(1))); var futureF = Task.Factory.ContinueWhenAll<int, int>( new[] { futureB, futureD }, ( tasks ) => F4(futureB.Result, futureD.Result)); futureF.ContinueWith(( t ) => Console.WriteLine("ResultF:" + t.Result) ); Console.WriteLine("Code...End"); |
...
JAVA와 C#코드가 흡사합니다. 복합된 비동기처리를 위한 방식은 여러가지 방법이 있겠으나
위와같이 람다식을 활용하는 방식이 진보된 방식입니다.
...
활용할수도 있습니다.
Promise (미래를 위한 약속)
퓨쳐가 읽기전용 용기라고하면, 퓨쳐자체를 반환하는것을 작성하고 싶을때는 Promice를 사용합니다.
Future 용기는 java/.net에 대응가능하지만 Promice를 Promise를 직접적으로 대응하는 키워드는 없는것으로 보입니다.
SCALA코드의 예를 통해 Promice의 Promise의 기능을 살펴보겠습니다.
Promice는 Promise는 퓨쳐에 비교하여 다음과 같은 특징을 가집니다.
- Promice는 Promise는 미래를 위한 약속이기때문에 단한번만 완료될수있습니다.(다시 완료시 예외발생)
- Promice는 Promise는 성공과 실패처리에대해 분리하여 처리할수 있습니다.
Promice 샘플 - KafkaSend
| Code Block | ||||
|---|---|---|---|---|
| ||||
def sendTokafka(recode: ProducerRecod): Futrure[RecordMetadata] = {
val promise : Promise[[RecordMetadata]] = Promise[RocordMetadata]() //RecordMetadata 타잎의 값을 돌려주는 약속을 만든다.
val future:Future[RecordMetadata] = promise.future //future에 대한 참조를 가져온다
val callback = new CallBack(){ //송신성공시 카프카 콜백
def onCompletition(metadata: RecordMetadata, e:Exception): Unit={
if(e != null ) promise.failure(e) //오류기록
else promise.success(metadata) //성공기록
}
}
producer.send(record,callback)
future
} |
퓨쳐를 조합하기
| Anchor | ||||
|---|---|---|---|---|
|
퓨쳐와 액터 조합하기
.net 에서 Actor 메시지와 Future(Task)를 조합한 샘플
| Code Block | ||||
|---|---|---|---|---|
| ||||
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);
}
} |
이것은 기존에 가진 모듈을(액터모델에 맞지않은) 모두 액터로 변환하여 불필요하게 복잡성을
늘릴필요가 없을시 기존 비동기처리 코드를 재사용하여 파이프를 통해 액터와 유연하게 연동이 가능합니다.
이렇게 사용했을시 부가적인 이득은 설정만으로 여러장치에 확장이가능하며 클러스터화가 될수 있다란것입니다.
이것은 동기적으로 작성된 로컬 로직을 비동기 분산처리로 확장할수 있는 가능성을 열어둘수가 있습니다.
...
액터에 블락킹을 요구하는 긴작업이 필요하게 될시 유용하게 사용할수 있습니다.
액터의 메시징 시스템을 블락킹하지 않고 Task에 실행을 동시성처리를 진행한후
액터메시지의 블락킹없이 그 결과를 다시 전송받을수 있습니다.
코틀린 기반
코틀린의 경우 자바가 지원하지 않는 async/await 를 지원합니다.
| Code Block | ||
|---|---|---|
| ||
import kotlinx.coroutines.*
fun main() = runBlocking {
val sumDeferred = async {
var sum = 0
for (i in 1..100) {
sum += i
}
sum
}
println("Sum: ${sumDeferred.await()}")
} |
AKKA의 Graph(DSL) 소개
Akka에서는 Graph를 활용하여, Future와 Promice를 더 우아하게 조합하여 흘러보냅니다.(+AkkaStream흘려보냅니다.
AkkaStream처리 방식이며 동시성 처리를 위한 이러한 GRAPH-DSL기법은, 언어스펙들이 높아지면서 기본으로 담고 있는경우도 있습니다.
(ex java8에는 없지만, 12에는 이러한 컨셉이 생김 : 실제 확인은 못해보았습니다. java8에서는 이러한 GraphStream방식을 akka를 통해서 복잡한 동시성처리를 Graph로 설계할수 있습니다.)
| Code Block | ||||||
|---|---|---|---|---|---|---|
| ||||||
actorSystem = ActorSystem.Create("ServiceB");
materializer = actorSystem.Materializer();
var g = RunnableGraph.FromGraph(GraphDsl.Create(builder =>
{
var source = Source.From(Enumerable.Range(1, 10));
var sink = Sink.Ignore<int>().MapMaterializedValue(_ => NotUsed.Instance);
var sinkConsole = Sink.ForEach<int>(x=>Console.WriteLine(x.ToString()))
.MapMaterializedValue(_ => NotUsed.Instance);
var broadcast = builder.Add(new Broadcast<int>(2));
var merge = builder.Add(new Merge<int>(2));
var f1 = Flow.Create<int>().Select(x => x + 10);
var f2 = Flow.Create<int>().Select(x => x + 10);
var f3 = Flow.Create<int>().Select(x => x + 10);
var f4 = Flow.Create<int>().Select(x => x + 10);
builder.From(source).Via(f1).Via(broadcast).Via(f2).Via(merge).Via(f3).To(sinkConsole);
builder.From(broadcast).Via(f4).To(merge);
return ClosedShape.Instance;
}));
g.Run(materializer); |
- in : 입력은 1~10까지입니다.
- f1 ~f4 : 각 팬을 지날떄마다 +10씩 더합니다.
- bcast : 분기가 일어나는 구간이며, 요소가 분기수만큼 복제가 됩니다.
- merge : 분기된 요소가 다시 집합하는 구간입니다.
- 녹색: 왼쪽에서 오른쪽으로 흐르는 하나의 흐름(혹은 위에서 아래로)
- 노랑: 분기가 갈라지거나 합해지는 구간( bcast : out이 2개 , merger : in 이 2개 )
- 레드: 분기 처리
Link : Working with Graphs
...