저작권 안내: 저작권자표시 Yes 상업적이용 No 컨텐츠변경 No

스프링5 입문

JSP 2.3

JPA 입문

DDD Start

인프런 객체 지향 입문 강의

스프링 리액터 로깅과 체크포인트


로깅

리액터의 동작을 보다 자세히 보고 싶다면 다음과 같이 log() 메서드를 사용한다. 아래 코드를 보자.


Flux.just(1, 2, 4, 5, 6)

        .log()

        .map(x -> x * 2)

        .subscribe(x -> logger.info("next: {}", x));


로깅 프레임워크로 SLF4j를 사용할 경우 실행한 결과는 다음과 같다.

08:38:29.990 [main] DEBUG reactor.util.Loggers$LoggerFactory - Using Slf4j logging framework
08:38:30.010 [main] INFO reactor.Flux.Array.1 - | onSubscribe([Synchronous Fuseable] FluxArray.ArraySubscription)
08:38:30.013 [main] INFO reactor.Flux.Array.1 - | request(unbounded)
08:38:30.014 [main] INFO reactor.Flux.Array.1 - | onNext(1)
08:38:30.014 [main] INFO logging.LoggingTest - next: 2
08:38:30.014 [main] INFO reactor.Flux.Array.1 - | onNext(2)
08:38:30.014 [main] INFO logging.LoggingTest - next: 4
08:38:30.014 [main] INFO reactor.Flux.Array.1 - | onNext(4)
08:38:30.014 [main] INFO logging.LoggingTest - next: 8
08:38:30.014 [main] INFO reactor.Flux.Array.1 - | onNext(5)
08:38:30.014 [main] INFO logging.LoggingTest - next: 10
08:38:30.014 [main] INFO reactor.Flux.Array.1 - | onNext(6)
08:38:30.014 [main] INFO logging.LoggingTest - next: 12
08:38:30.015 [main] INFO reactor.Flux.Array.1 - | onComplete()

"reactor.Flux.Array.1"이라는 로거가 출력한 로그 메시지는 Flux.just()가 생성한 시퀀스의 동작을 로그로 남긴 것이다. 로그를 보면 시퀀스가 request() 신호를 받은 시점, next 신호(onNext(2) 등)나 complete 신호(onComplete())를 발생한 시점을 확인할 수 있다.


로그 레벨은 INFO인데 로그 레벨을 변경하고 싶다면 다음과 같이 log() 메서드를 사용하면 된다.


Flux.just(1, 2, 4, 5, 6)

        .log(null, Level.FINE) // java.util.logging.Level 타입

        .subscribe(x -> logger.info("next: {}", x));


두 번째 인자로 자바 로깅의 Level.FINE을 주었다. SLF4j를 사용할 경우 리액터는 자바의 FINE 레벨을 SLF4j의 DEBUG 레벨로 기록한다. 따라서 위 코드를 실행하면 다음과 같이 DEBUG 레벨로 로그를 남기는 것을 확인할 수 있다.


08:50:30.098 [main] DEBUG reactor.Flux.Array.1 - | onSubscribe([Synchronous Fuseable] FluxArray.ArraySubscription)

08:50:30.101 [main] DEBUG reactor.Flux.Array.1 - | request(unbounded)

08:50:30.102 [main] DEBUG reactor.Flux.Array.1 - | onNext(1)

08:50:30.102 [main] INFO logging.LoggingTest - next: 1

08:50:30.102 [main] DEBUG reactor.Flux.Array.1 - | onNext(2)

08:50:30.102 [main] INFO logging.LoggingTest - next: 2


다음과 같이 특정 로거를 이용하도록 지정할 수도 있다. 


Flux.just(1, 2, 4, 5, 6)

        .log("MYLOG") // 또는 log("MYLOG", Level.INFO)

        .subscribe(x -> logger.info("next: {}", x));


위 코드를 실행하면 다음과 같이 지정한 로거를 이용해서 로그를 남긴다.


08:51:55.180 [main] INFO MYLOG - | onSubscribe([Synchronous Fuseable] FluxArray.ArraySubscription)

08:51:55.184 [main] INFO MYLOG - | request(unbounded)

08:51:55.184 [main] INFO MYLOG - | onNext(1)

08:51:55.184 [main] INFO logging.LoggingTest - next: 1

08:51:55.184 [main] INFO MYLOG - | onNext(2)

08:51:55.184 [main] INFO logging.LoggingTest - next: 2

08:51:55.184 [main] INFO MYLOG - | onNext(4)


체크포인트

시퀀스가 신호를 발생하는 과정에서 익셉션이 발생하면 어떻게 될까? 시퀀스가 여러 단게를 거쳐 변환한다면 어떤 시점에 익셉션이 발생했는지 단번에 찾기 힘들 수도 있다. 이럴 때 도움이 되는 것이 체크포인트이다. 다음은 체크포인트 사용 예이다.


Flux.just(1, 2, 4, -1, 5, 6)

        .map(x -> x + 1)

        .checkpoint("MAP1")

        .map(x -> 10 / x) // 원본 데이터가 -1인 경우 x는 0이 되어 익셉션이 발생

        .checkpoint("MAP2")

        .subscribe(

                x -> System.out.println("next: " + x),

                err -> err.printStackTrace());


이 코드는 데이터에 1을 더하고 다시 10을 데이터로 나누는 변환을 수행한다. 원본 데이터에 -1이 있으므로 중간에 0으로 나누게 되어 익셉션이 발생하게 된다. checkpoint()를 사용하면 어떤 단계에서 익셉션이 발생했는지 쉽게 확인할 수 있다. 아래 코드는 익셉션이 발생했을 때 출력한 익셉션 트레이스 메시지인데 이 메시지를 보면 checkpoint()로 지정한 description이 익셉션 트레이스 마지막에 출력되는 것을 알 수 있다. 이를 통해 어느 과정에서 익셉션이 발생했는지 쉽게 찾을 수 있다.

java.lang.ArithmeticException: / by zero
    at logging.CheckpointTest.lambda$checkpoint$1(CheckpointTest.java:15)
    at reactor.core.publisher.FluxMapFuseable$MapFuseableSubscriber.onNext(FluxMapFuseable.java:107)
    ...생략
    Suppressed: reactor.core.publisher.FluxOnAssembly$OnAssemblyException: 
Assembly site of producer [reactor.core.publisher.FluxMapFuseable] is identified by light checkpoint [MAP2]."description" : "MAP2"



관련글


Posted by 최범균 madvirus

댓글을 달아 주세요

리액터 윈도우


일정 개수로 묶어서 Flux 만들기: window(int), window(int, int)

Flux#window(int) 메서드를 사용하면 시퀀스가 발생시키는 데이터를 일정 개수로 묶을 수 있다. 다음은 예제 코드이다.


Flux<Flux<Integer>> windowSeq = 

        Flux.just(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

             .window(4); // 4개 간격으로 4개씩 새로운 Flux로 묶음


windowSeq.subscribe(seq -> { // seq는 Flux<Integer>

    Mono<List<Integer>> monoList = seq.collectList();

    monoList.subscribe(list -> logger.info("window: {}", list));

});


위 코드에서 Flux#window(4)가 리턴하는 타입은 Flux<Flux<Integer>>이다. 즉 값이 Flux<Integer>인 Flux를 리턴한다. 이 시퀀스(Flux<Integer>)가 발생하는 값의 개수는 최대 4개이다. 위 코드의 실행 결과는 다음과 같다. 결과를 보면 4개씩 데이터를 묶어서 하나의 Flux로 만든 것을 알 수 있다.


01:19:52.388 [parallel-2] INFO batch.WindowTest - window: [5, 6, 7, 8]

01:19:52.388 [parallel-1] INFO batch.WindowTest - window: [1, 2, 3, 4]

01:19:52.391 [parallel-1] INFO batch.WindowTest - window: [9, 10]


Flux.window(int maxSize, int skip) 메서드를 사용하면 어느 간격으로 데이터를 묶을지 정할 수 있다. 두 번째 파라미터는 몇 개씩 건너서 데이터를 묶을 지 결정한다. 예를 들어 다음 코드를 보자.


Flux<Flux<Integer>> windowSeq =

        Flux.just(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

                .window(4, 3); // 3개 간격마다 4개씩 새로운 Flux로 묶음


windowSeq.subscribe(seq -> { // seq는 Flux<Integer>

    Mono<List<Integer>> monoList = seq.collectList();

    monoList.subscribe(list -> logger.info("window: {}", list));

});


위 코드는 두 번째 인자로 3을 주었다. 이 경우 3개 데이터 간격으로 4개씩 데이터를 묶는다. 데이터를 묶는 간격이 데이터를 묶는 개수보다 작으므로 일부 데이터에 중복이 발생한다.


15:18:37.898 [main] INFO batch.WindowTest - window: [1, 2, 3, 4]

15:18:37.898 [main] INFO batch.WindowTest - window: [4, 5, 6, 7]

15:18:37.898 [main] INFO batch.WindowTest - window: [7, 8, 9, 10]

15:18:37.898 [main] INFO batch.WindowTest - window: [10]


다음과 같이 skip 파라미터 값으로 5를 주면 어떻게 될까? 데이터를 묶는 개수보다 간격이 더 크므로 일부 데이터에 누락이 발생할 것이다. 


Flux<Flux<Integer>> windowSeq2 =

        Flux.just(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

                .window(4, 5); // 5개 간격마다 4개씩 새로운 Flux 묶음


// 첫 번째 Flux<Integer> : [1, 2, 3, 4]
// 두 번째 Flux<Integer> : [6, 7, 8, 9]



일정 시간 간격으로 묶어서 Flux 만들기: window(Duration), window(Duration, Duration)

Flux#window(Duration) 메서드를 사용하면 시퀀스가 발생시키는 데이터를 일정 시간마다 묶을 수 있다. 다음은 예제 코드이다.


Flux<Flux<Long>> windowSeq = Flux.interval(Duration.ofMillis(100))

      .window(Duration.ofMillis(500)); // 500밀리초 간격마다 500밀리초 동안 데이터 묶음


이 코드는 500밀리초(0.5초) 동안 발생한 데이터를 묶는다.


데이터를 묶기 시작하는 간격을 지정하고 싶다면 Flux#window(Duration, Duration) 메서드를 사용한다.


Flux<Flux<Long>> windowSeq = Flux.interval(Duration.ofMillis(100))

        // 400밀리초 간격마다 500밀리초 동안 데이터 묶음

        .window(Duration.ofMillis(500), Duration.ofMillis(400))



특정 조건에 다다를 때가지 묶어서 Flux 만들기: windowUntil(Predicate)

특정 조건을 충족하는 데이터를 만날 때까지 묶어서 Flux로 만들고 싶다면 windowUntil()을 사용한다. 다음은 사용 예이다.


Flux.just(1,1,2,3,3,4,5)

        .windowUntil(x -> x % 2 == 0)

        .subscribe((Flux<Integer> seq) -> {

            seq.collectList().subscribe(lst -> logger.info("window: {}", lst));

        });


위 코드는 2로 나눠서 나머지가 0인(즉 짝수인) 값을 만날 때까지 묶는다. 실제 실행 결과를 보면 다음과 같다.


01:19:27.166 [main] INFO batch.WindowTest - window: [1, 1, 2]

01:19:27.169 [main] INFO batch.WindowTest - window: [3, 3, 4]

01:19:27.169 [main] INFO batch.WindowTest - window: [5]


다음과 같이 마지막 데이터가 조건에 해당하면 어떻게 될까?


Flux.just(1,1,2,3,3,4)

        .windowUntil(x -> x % 2 == 0)

        .subscribe(seq -> {

            seq.collectList().subscribe(lst -> logger.info("window: {}", lst));

        });


결과를 보면 다음과 같이 마지막에 빈 Flux가 하나 더 발생되는 것을 알 수 있다.


17:23:22.724 [main] INFO batch.WindowTest - window: [1, 1, 2]

17:23:22.727 [main] INFO batch.WindowTest - window: [3, 3, 4]

17:23:22.727 [main] INFO batch.WindowTest - window: []


특정 조건을 충족하는 동안 묶어서 Flux 만들기: windowWhile(Predicate)

Flux#windowWhile(Predicate)은 해당 조건을 충족하지 않는 데이터가 나올 때까지 묶어서 Flux를 만든다. 조건을 충족하지 않는 데이터로 시작하거나 연속해서 데이터가 조건을 충족하지 않으면 빈 윈도우를 생성한다.


Flux.just(1,1,2,4,3,3,4,6,8,9,10)

        .windowWhile(x -> x % 2 == 0) // 짝수인 동안

        .subscribe(seq -> {

            seq.collectList().subscribe(lst -> logger.info("window: {}", lst));

        });


이 코드의 결과는 다음과 같다.


01:07:00.239 [main] INFO batch.WindowTest - window: []

01:07:00.242 [main] INFO batch.WindowTest - window: []

01:07:00.242 [main] INFO batch.WindowTest - window: [2, 4]

01:07:00.242 [main] INFO batch.WindowTest - window: []

01:07:00.242 [main] INFO batch.WindowTest - window: [4, 6, 8]

01:07:00.242 [main] INFO batch.WindowTest - window: [10]


Flux 대신 List로 묶기: buffer류 메서드

window류 메서드가 Flux로 묶는다면 buffer류 메서드는 Collection으로 묶는다. 메서드 이름이 window에서 buffer로 바뀔뿐 시그너쳐는 동일하다. 다음은 buffer류 메서드의 사용 예이다.


Flux<List<Integer>> bufferSeq = Flux.just(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).buffer(4);

bufferSeq.subscribe(list -> logger.info("window: {}", list));



관련글




Posted by 최범균 madvirus

댓글을 달아 주세요

병렬(Parallel) 처리

시퀀스는 순차적으로 next 신호를 발생하고 Subscriber는 순차적으로 신호를 처리한다. 리액터는 시퀀스가 발생하는 next 신호를 병렬로 처리할 수 있는 방법을 제공한다. 이 글에서는 Flux의 parallel()을 사용하는 방법과 zip()을 이용한 방법에 대해 살펴본다.


parallel()과 runOn()으로 Flux 병렬 처리하기

Flux#parallel()과 runOn()을 사용하면 Flux가 생성하는 next 신호를 병렬로 처리할 수 있다. 다음 예를 보자.


Flux.range(1, 20)

        .parallel(2) // 작업을 레일로 나누기만 함

        .runOn(Schedulers.newParallel("PAR", 2))  // 각 레일을 병렬로 실행

        .map(x -> {

            int sleepTime = nextSleepTime(x % 2 == 0 ? 50 : 100, x % 2 == 0 ? 150 : 300);

            logger.info("map1 {}, sleepTime {}", x, sleepTime);

            sleep(sleepTime);

            return String.format("%02d", x);

        })

        .subscribe(i -> logger.info("next {}", i) );


// nextSleepTime은 인자로 받은 두 정수 값 범위에 해당하는 임의의 값을 생성한다고 가정


Flux#parallel(int parallelism) 메서드는 Flux가 생성하는 next 신호를 parallelism 개수만큼 라운드 로빈 방식으로 신호를 나눈다. 분리한 신호는 일종의 신호를 전달할 레일(rail)을 구성한다. 위 코드는 2를 값으로 주었으므로 2개의 레일을 생성한다. 라운드 로빈 방식을 사용해서 각 레일에 값을 전달하므로 위 코드는 [1, 3, 5, .., 19]를 제공하는 레일과 [2, 4, 6, ..., 20]를 제공하는 레일을 생성한다.


parallel()로 여러 레일을 만든다고 해서 병렬로 신호를 처리하는 것은 아니다. parallel()은 병렬로 신호를 처리할 수 있는 ParallelFlux를 리턴하는데, ParallelFlux의 runOn() 메서드에 다중 쓰레드를 사용하는 스케줄러를 전달해야 병렬로 신호를 처리할 수 있다. 위 코드는 2개 쓰레드를 사용하는 parallel 스케줄러를 전달했으므로 동시에 2개 레일로부터 오는 신호를 처리하게 된다.


병렬로 처리되는 것을 확인하기 위해 map() 메서드는 값이 짝수인 경우 50~150 밀리초, 홀수인 경우 100~300 밀리초 동안 슬립하고 문자열로 변환한 값을 리턴하도록 구현했다. parallel()은 라운드 로빈 방식으로 레일을 나누므로 짝수 레일과 홀수 레일이 생성되므로 슬립 타임 구간이 작은 짝수 레일이 더 빨리 끝나게 된다.


실제 결과를 확인해보자.


13:45:14.272 [PAR-1] INFO parallel.ParallelTest - map1 1, sleepTime 117

13:45:14.272 [PAR-2] INFO parallel.ParallelTest - map1 2, sleepTime 96

13:45:14.378 [PAR-2] INFO parallel.ParallelTest - next 02

13:45:14.378 [PAR-2] INFO parallel.ParallelTest - map1 4, sleepTime 98

13:45:14.399 [PAR-1] INFO parallel.ParallelTest - next 01

13:45:14.399 [PAR-1] INFO parallel.ParallelTest - map1 3, sleepTime 268

13:45:14.477 [PAR-2] INFO parallel.ParallelTest - next 04

13:45:14.477 [PAR-2] INFO parallel.ParallelTest - map1 6, sleepTime 93

13:45:14.570 [PAR-2] INFO parallel.ParallelTest - next 06

...생략

13:45:14.868 [PAR-2] INFO parallel.ParallelTest - map1 16, sleepTime 50

13:45:14.905 [PAR-1] INFO parallel.ParallelTest - next 05

13:45:14.905 [PAR-1] INFO parallel.ParallelTest - map1 7, sleepTime 201

13:45:14.918 [PAR-2] INFO parallel.ParallelTest - next 16

13:45:14.918 [PAR-2] INFO parallel.ParallelTest - map1 18, sleepTime 122

13:45:15.040 [PAR-2] INFO parallel.ParallelTest - next 18

13:45:15.040 [PAR-2] INFO parallel.ParallelTest - map1 20, sleepTime 62

13:45:15.102 [PAR-2] INFO parallel.ParallelTest - next 20

13:45:15.106 [PAR-1] INFO parallel.ParallelTest - next 07

13:45:15.106 [PAR-1] INFO parallel.ParallelTest - map1 9, sleepTime 202

13:45:15.308 [PAR-1] INFO parallel.ParallelTest - next 09

13:45:15.308 [PAR-1] INFO parallel.ParallelTest - map1 11, sleepTime 131

13:45:15.439 [PAR-1] INFO parallel.ParallelTest - next 11

13:45:15.439 [PAR-1] INFO parallel.ParallelTest - map1 13, sleepTime 289

13:45:15.728 [PAR-1] INFO parallel.ParallelTest - next 13

13:45:15.728 [PAR-1] INFO parallel.ParallelTest - map1 15, sleepTime 288

13:45:16.017 [PAR-1] INFO parallel.ParallelTest - next 15

13:45:16.017 [PAR-1] INFO parallel.ParallelTest - map1 17, sleepTime 156

13:45:16.173 [PAR-1] INFO parallel.ParallelTest - next 17

13:45:16.173 [PAR-1] INFO parallel.ParallelTest - map1 19, sleepTime 247

13:45:16.420 [PAR-1] INFO parallel.ParallelTest - next 19


실행 결과를 보면 PAR-1 쓰레드는 홀수를 PAR-2는 짝수를 처리하는 것을 알 수 있다. 즉 쓰레드마다 한 레일을 처리하고 있다. 짝수인 경우 슬립 타임을 더 작은 범위로 주었으므로 짝수 레일을 처리한 PAR-2가 먼저 레일을 처리하고 있다.

아래와 같이 레일은 4개로 나누었는데 쓰레드가 2개인 병렬 스케줄러를 사용하면 어떻게 될까?

Flux.range(1, 20)
        .parallel(4)
        .runOn(Schedulers.newParallel("PAR", 2))
        .map(x -> {
            ...
        })
        .subscribe(i -> logger.info("next {}", i) );


이 경우 스케줄러는 2개의 레일을 먼저 처리한다. 한 레일에 남아 있는 데이터가 없으면 데이터가 남아 있는 다른 레일을 처리한다.


레일당 크기

ParallelFlux#runOn() 메서드는 기본적으로 한 레일 당 Queues.SMALL_BUFFER_SIZE 만큼의 데이터를 저장한다. (이 값은 reactor.bufferSize.small 시스템 프로퍼티 값을 사용하는데 이 값을 지정하지 않으면 256을 사용하고 이 값이 16보다 작으면 16을 사용한다.)


레일에 미리 채울 데이터 개수를 변경하려면 다음과 같이 runOn() 메서드의 두 번째 인자로 값을 주면 된다. 다음 코드는 레일에 미리 채울 값(prefetch)으로 2를 사용한 예이다.


Flux.range(1, 20)

        .parallel(4)

        .runOn(Schedulers.newParallel("PAR", 2), 2) // 레일에 미리 채울 값으로 2 사용

        .subscribe(x -> logger.info("next {}", x));


위 코드의 경우 최초에 각 레일에 다음과 같이 데이터가 채워진다.

레일0: 1, 5
레일1: 2, 6
레일2: 3, 7
레일3: 4, 8


스케줄러는 2개의 쓰레드를 사용하는데 두 쓰레드를 PAR-1, PAR-2라고 하자. 이 두 쓰레드가 처음에 각각 레일0과 레일1을 선택했다고 하자.


레일0: 1, 5 (PAR-1)
레일1: 2, 6 (PAR-2)
레일2: 3, 7
레일3: 4, 8

두 쓰레드가 레일의 데이터를 처리하면 상태는 다음과 같이 바뀐다.


레일0: (PAR-1)
레일1: (PAR-2)
레일2: 3, 7
레일3: 4, 8

이 상태에서 PAR-2가 레일1이 비어있는지 여부를 검사한다면 레일이 비워져 있으므로 다음 레일을 선택한다. 이때 레일3을 선택했다고 하자. 그리고 PAR-1이 레일0이 비어있는지 여부를 검사하기 전에 레일0과 레일1이 채워졌다고 하자. 그럼 상태는 다음과 같이 바뀐다.


레일0: 9 (PAR-1)
레일1: 10
레일2: 3, 7 
레일3: 4, 8 (PAR-2)

그러면 PAR-2는 4를 처리하고 PAR-1은 9를 처리한다. PAR-1이 9를 처리하는 동안에 레일0에 데이터가 채워지지 않았다면 다음 레일을 선택하는데 이때 레일1을 선택할 수 있다.

레일0: 11,
레일1: 10 (PAR-1)
레일2: 3, 7 
레일3: 8 (PAR-2)

이렇게 병렬 스케줄러의 쓰레드 개수가 레일 개수보다 작으면 그때 그때 레일의 데이터 개수에 따라 스케줄러가 선택하는 레일이 달라지게 된다.

Mono.zip()으로 병렬 처리하기

각 Mono의 구독 처리 쓰레드를 병렬 스케줄러로 실행하고 Mono.zip() 메서드를 이용해서 Mono를 묶으면 각 Mono를 병렬로 처리할 수 있다. 다음은 예제 코드이다.


Mono m1 = Mono.just(1).map(x -> {

    logger.info("1 sleep");

    sleep(1500);

    return x;

}).subscribeOn(Schedulers.parallel());


Mono m2 = Mono.just(2).map(x -> {

    logger.info("2 sleep");

    sleep(3000);

    return x;

}).subscribeOn(Schedulers.parallel());


Mono m3 = Mono.just(3).map(x -> {

    logger.info("3 sleep");

    sleep(2000);

    return x;

}).subscribeOn(Schedulers.parallel());


logger.info("Mono.zip(m1, m2, m3)");


Mono.zip(m1, m2, m3)

        .subscribe(tup -> logger.info("next: {}", tup);


위 코드에서 m1, m2, m3는 각각 1.5초, 3초, 2초간 슬립한다. 각각은 subscribeOn()을 이용해서 Parallel 스케줄러를 이용해서 구독 요청을 처리하도록 했다. 그리고 Mono.zip()으로 m1, m2, m3를 묶었다.


실제 실행 결과를 보면 m1, m2, m3가 슬립을 동시에 시작하고 약 3초 뒤에 세 Mono의 값을 묶은 Tuple3의 값을 출력하는 것을 알 수 있다. 이를 통해 m1, m2, m3를 동시에 실행했음을 확인할 수 있다.


16:12:34.424 [main] INFO parallel.ParallelTest - Mono.zip(m1, m2, m3)

16:12:34.447 [parallel-1] INFO parallel.ParallelTest - 1 sleep

16:12:34.447 [parallel-3] INFO parallel.ParallelTest - 3 sleep

16:12:34.447 [parallel-2] INFO parallel.ParallelTest - 2 sleep

16:12:37.469 [parallel-2] INFO parallel.ParallelTest - next: [1,2,3]



관련 글


Posted by 최범균 madvirus

댓글을 달아 주세요

리액터 쓰레드 스케줄링

리액터는 비동기 실행을 강제하지 않는다. 예를 들어 아래 코드를 보자.


Flux.range(1, 3)

        .map(i -> {

            logger.info("map {} to {}", i, i + 2);

            return i + 2;

        })

        .flatMap(i -> {

            logger.info("flatMap {} to Flux.range({}, {})", i, 1, i);

            return Flux.range(1, i);

        })

        .subscribe(i -> logger.info("next " + i));


위 코드에서 logger는 쓰레드 이름을 남기도록 설정한 로거라고 하자. 위 코드를 main 메서드에서 실행하면 다음과 같은 결과를 출력한다.


17:44:57.180 [main] INFO schedule.ScheduleTest - map 1 to 3

17:44:57.183 [main] INFO schedule.ScheduleTest - flatMap 3 to Flux.range(1, 3)

17:44:57.202 [main] INFO schedule.ScheduleTest - next 1

17:44:57.202 [main] INFO schedule.ScheduleTest - next 2

17:44:57.202 [main] INFO schedule.ScheduleTest - next 3

17:44:57.202 [main] INFO schedule.ScheduleTest - map 2 to 4

17:44:57.202 [main] INFO schedule.ScheduleTest - flatMap 4 to Flux.range(1, 4)

17:44:57.202 [main] INFO schedule.ScheduleTest - next 1

17:44:57.202 [main] INFO schedule.ScheduleTest - next 2

17:44:57.202 [main] INFO schedule.ScheduleTest - next 3

17:44:57.202 [main] INFO schedule.ScheduleTest - next 4

17:44:57.202 [main] INFO schedule.ScheduleTest - map 3 to 5

17:44:57.202 [main] INFO schedule.ScheduleTest - flatMap 5 to Flux.range(1, 5)

17:44:57.203 [main] INFO schedule.ScheduleTest - next 1

17:44:57.203 [main] INFO schedule.ScheduleTest - next 2

17:44:57.203 [main] INFO schedule.ScheduleTest - next 3

17:44:57.203 [main] INFO schedule.ScheduleTest - next 4

17:44:57.203 [main] INFO schedule.ScheduleTest - next 5


실행 결과를 보면 map(), flatMap(), subscribe()에 전달한 코드가 모두 main 쓰레드에서 실행된 것을 알 수 있다. 즉 map 연산, flatMap 연산뿐만 아니라 subscribe를 이용한 구독까지 모두 main 쓰레드가 실행한다.


스케줄러를 사용하면 구독이나 신호 처리를 별도 쓰레드로 실행할 수 있다.


publishOn을 이용한 신호 처리 쓰레드 스케줄링

publishOn() 메서드를 이용하면 next, complete, error신호를 별도 쓰레드로 처리할 수 있다. map(), flatMap() 등의 변환도 publishOn()이 지정한 쓰레드를 이용해서 처리한다. 다음 코드를 보자.


CountDownLatch latch = new CountDownLatch(1);

Flux.range(1, 6)

        .map(i -> {

            logger.info("map 1: {} + 10", i);

            return i + 10;

        })

        .publishOn(Schedulers.newElastic("PUB"), 2)

        .map(i -> { // publishOn에서 지정한 PUB 스케줄러가 실행

            logger.info("map 2: {} + 10", i);

            return i + 10;

        })

        .subscribe(new BaseSubscriber<Integer>() {

            @Override

            protected void hookOnSubscribe(Subscription subscription) {

                logger.info("hookOnSubscribe");

                requestUnbounded();

            }


            @Override

            protected void hookOnNext(Integer value) {

                logger.info("hookOnNext: " + value); // publishOn에서 지정한 스케줄러가 실행

            }


            @Override

            protected void hookOnComplete() {

                logger.info("hookOnComplete"); // publishOn에서 지정한 스케줄러가 실행

                latch.countDown();

            }

        });

latch.await();


publishOn()은 두 개의 인자를 받는다. 이 코드에서 첫 번째 인자인 Schedulers.newElastic("PUB")은 비동기로 신호를 처리할 스케줄러이다. 다양한 스케줄러가 존재하는데 이에 대해서는 뒤에서 다시 살펴본다. 일단 지금은 스케줄러가 별도 쓰레드를 이용해서 신호를 처리한다고 생각하면 된다.


두 번째 인자인 2는 스케줄러가 신호를 처리하기 전에 미리 가져올 (prefetch) 데이터 개수이다. 이는 스케줄러가 생성하는 비동기 경계 시점에 보관할 수 있는 데이터의 개수로 일종의 버퍼 크기가 된다.


위 코드를 실제로 실행하면 어떤 일이 벌어지는지 보자. 다음은 결과이다.


13:01:03.026 [main] INFO schedule.ScheduleTest - hookOnSubscribe

13:01:03.029 [main] INFO schedule.ScheduleTest - map 1: 1 + 10

13:01:03.030 [main] INFO schedule.ScheduleTest - map 1: 2 + 10


13:01:03.031 [PUB-2] INFO schedule.ScheduleTest - map 2: 11 + 10

13:01:03.037 [PUB-2] INFO schedule.ScheduleTest - hookOnNext: 21

13:01:03.037 [PUB-2] INFO schedule.ScheduleTest - map 2: 12 + 10

13:01:03.037 [PUB-2] INFO schedule.ScheduleTest - hookOnNext: 22

13:01:03.037 [PUB-2] INFO schedule.ScheduleTest - map 1: 3 + 10

13:01:03.038 [PUB-2] INFO schedule.ScheduleTest - map 1: 4 + 10

13:01:03.038 [PUB-2] INFO schedule.ScheduleTest - map 2: 13 + 10

13:01:03.038 [PUB-2] INFO schedule.ScheduleTest - hookOnNext: 23

13:01:03.038 [PUB-2] INFO schedule.ScheduleTest - map 2: 14 + 10

13:01:03.038 [PUB-2] INFO schedule.ScheduleTest - hookOnNext: 24

13:01:03.038 [PUB-2] INFO schedule.ScheduleTest - map 1: 5 + 10

13:01:03.038 [PUB-2] INFO schedule.ScheduleTest - map 1: 6 + 10

13:01:03.038 [PUB-2] INFO schedule.ScheduleTest - map 2: 15 + 10

13:01:03.038 [PUB-2] INFO schedule.ScheduleTest - hookOnNext: 25

13:01:03.038 [PUB-2] INFO schedule.ScheduleTest - map 2: 16 + 10

13:01:03.038 [PUB-2] INFO schedule.ScheduleTest - hookOnNext: 26

13:01:03.038 [PUB-2] INFO schedule.ScheduleTest - hookOnComplete


최초에 2개를 미리 가져올 때를 제외하면 나머지는 모두 publishOn()으로 전달한 스케줄러의 쓰레드(쓰레드 이름이 "PUB"로 시작)가 처리하는 것을 알 수 있다.


publishOn()에 지정한 스케줄러는 다음 publishOn()을 설정할 때까지 적용된다. 예를 들어 다음과 같이 이름이 PUB1과 PUB2인 두 개의 스케줄러를 설정했다고 하자.


Flux.range(1, 6)

        .publishOn(Schedulers.newElastic("PUB1"), 2)

        .map(i -> {

            logger.info("map 1: {} + 10", i);

            return i + 10;

        })

        .publishOn(Schedulers.newElastic("PUB2"))

        .map(i -> {

            logger.info("map 2: {} + 10", i);

            return i + 10;

        })

        .subscribe(new BaseSubscriber<Integer>() {

            @Override

            protected void hookOnSubscribe(Subscription subscription) {

                logger.info("hookOnSubscribe");

                requestUnbounded();

            }


            @Override

            protected void hookOnNext(Integer value) {

                logger.info("hookOnNext: " + value);

            }


            @Override

            protected void hookOnComplete() {

                logger.info("hookOnComplete");

                latch.countDown();

            }

        });


이 코드를 실행한 결과는 다음과 같다.


13:38:14.957 [main] INFO schedule.ScheduleTest - hookOnSubscribe

13:38:14.960 [PUB1-4] INFO schedule.ScheduleTest - map 1: 1 + 10

13:38:14.963 [PUB1-4] INFO schedule.ScheduleTest - map 1: 2 + 10

13:38:14.963 [PUB2-3] INFO schedule.ScheduleTest - map 2: 11 + 10

13:38:14.963 [PUB1-4] INFO schedule.ScheduleTest - map 1: 3 + 10

13:38:14.964 [PUB1-4] INFO schedule.ScheduleTest - map 1: 4 + 10

13:38:14.964 [PUB1-4] INFO schedule.ScheduleTest - map 1: 5 + 10

13:38:14.964 [PUB1-4] INFO schedule.ScheduleTest - map 1: 6 + 10

13:38:14.969 [PUB2-3] INFO schedule.ScheduleTest - hookOnNext: 21

13:38:14.979 [PUB2-3] INFO schedule.ScheduleTest - map 2: 12 + 10

13:38:14.979 [PUB2-3] INFO schedule.ScheduleTest - hookOnNext: 22

...생략

13:38:15.021 [PUB2-3] INFO schedule.ScheduleTest - map 2: 16 + 10

13:38:15.021 [PUB2-3] INFO schedule.ScheduleTest - hookOnNext: 26

13:38:15.031 [PUB2-3] INFO schedule.ScheduleTest - hookOnComplete


결과를 보면 첫 번째 publishOn()과 두 번째 publishOn() 사이의 map() 처리는 PUB1 스케줄러가 실행하고 두 번째 publishOn() 이후의 map(), 신호 처리는 PUB2 스케줄러가 실행한 것을 알 수 있다.


subscribeOn을 이용한 구독 처리 쓰레드 스케줄링

subscribeOn()을 사용하면 Subscriber가 시퀀스에 대한 request 신호를 별도 스케줄러로 처리한다. 즉 시퀀스(Flux나 Mono)를 실행할 스케줄러를 지정한다. 다음은 subscribeOn()의 사용예이다.


CountDownLatch latch = new CountDownLatch(1);

Flux.range(1, 6)

        .log() // 보다 상세한 로그 출력 위함

        .subscribeOn(Schedulers.newElastic("SUB"))

        .map(i -> {

            logger.info("map: {} + 10", i);

            return i + 10;

        })

        .subscribe(new BaseSubscriber<Integer>() {

            @Override

            protected void hookOnSubscribe(Subscription subscription) {

                logger.info("hookOnSubscribe"); // main thread

                request(1);

            }


            @Override

            protected void hookOnNext(Integer value) {

                logger.info("hookOnNext: " + value); // SUB 쓰레드

                request(1);

            }


            @Override

            protected void hookOnComplete() {

                logger.info("hookOnComplete"); // SUB 쓰레드

                latch.countDown();

            }

        });


latch.await();


subscribeOn()으로 지정한 스케줄러는 시퀀스의 request 요청 처리뿐만 아니라 첫 번째 publishOn() 이전까지의 신호 처리를 실행한다. 따라서 위 코드를 실행하면 Flux.range()가 생성한 시퀀스의 신호 발생뿐만 아니라 map() 실행, Subscriber의 next, complete 신호 처리를 "SUB" 스케줄러가 실행한다. 참고로 시퀀스의 request 요청과 관련된 로그를 보기 위해 log() 메서드를 사용했다.


다음은 실행 결과이다.


14:56:24.996 [main] INFO schedule.ScheduleTest - hookOnSubscribe

14:56:25.005 [SUB-2] INFO reactor.Flux.Range.1 - | onSubscribe([Synchronous Fuseable] FluxRange.RangeSubscription)

14:56:25.010 [SUB-2] INFO reactor.Flux.Range.1 - | request(1)

14:56:25.010 [SUB-2] INFO reactor.Flux.Range.1 - | onNext(1)

14:56:25.011 [SUB-2] INFO schedule.ScheduleTest - map: 1 + 10

14:56:25.016 [SUB-2] INFO schedule.ScheduleTest - hookOnNext: 11

14:56:25.016 [SUB-2] INFO reactor.Flux.Range.1 - | request(1)

14:56:25.016 [SUB-2] INFO reactor.Flux.Range.1 - | onNext(2)

14:56:25.016 [SUB-2] INFO schedule.ScheduleTest - map: 2 + 10

14:56:25.017 [SUB-2] INFO schedule.ScheduleTest - hookOnNext: 12

...(생략)

14:56:25.017 [SUB-2] INFO reactor.Flux.Range.1 - | request(1)

14:56:25.017 [SUB-2] INFO reactor.Flux.Range.1 - | onNext(6)

14:56:25.017 [SUB-2] INFO schedule.ScheduleTest - map: 6 + 10

14:56:25.017 [SUB-2] INFO schedule.ScheduleTest - hookOnNext: 16

14:56:25.017 [SUB-2] INFO reactor.Flux.Range.1 - | request(1)

14:56:25.018 [SUB-2] INFO reactor.Flux.Range.1 - | onComplete()

14:56:25.018 [SUB-2] INFO schedule.ScheduleTest - hookOnComplete


실행 결과에서 Flux.Range 타입은 Flux.range() 메서드가 생성한 시퀀스 객체의 타입이다. 위 결과에서 Flux.Range.1의 reques(1), onNext(), onComplete() 로그는 Subscriber의 request 신호를 처리하는 로그이다. 이 로그를 보면 SUB 스케줄러가 해당 기능을 실행하고 있음을 알 수 있다. 또한 map()과 Subscriber의 신호 처리 메서드(hookOnNext, hookOnComplete)도 SUB 스케줄러가 실행하고 있다.


subscribeOn() + publishOn() 조합

앞서 말했듯이 subscribeOn으로 지정한 스케줄러는 첫 번째 publishOn이 올때까지 적용된다. 다음 코드를 통해 이를 확인할 수 있다.


CountDownLatch latch = new CountDownLatch(1);

Flux.range(1, 6)

        .log()

        .subscribeOn(Schedulers.newElastic("SUB"))

        .map(i -> {

            logger.info("map1: " + i + " --> " + (i + 20));

            return i + 20;

        })

        .map(i -> {

            logger.info("mapBySub: " + i + " --> " + (i + 100));

            return i + 100;

        })

        .publishOn(Schedulers.newElastic("PUB1"), 2)

        .map(i -> {

            logger.info("mapByPub1: " + i + " --> " + (i + 1000));

            return i + 1000;

        })

        .publishOn(Schedulers.newElastic("PUB2"), 2)

        .subscribe(new BaseSubscriber<Integer>() {

            @Override

            protected void hookOnSubscribe(Subscription subscription) {

                logger.info("hookOnSubscribe");

                request(1);

            }


            @Override

            protected void hookOnNext(Integer value) {

                logger.info("hookOnNext: " + value);

                request(1);

            }


            @Override

            protected void hookOnComplete() {

                logger.info("hookOnComplete");

                latch.countDown();

            }

        });


latch.await();


이 코드는 구독을 위한 "SUB" 스케줄러와 신호 처리를 위한 "PUB1", "PUB2" 스케줄러를 설정하고 있다. 


다음은 실행 결과이다.


15:10:05.660 [main] INFO schedule.ScheduleTest - hookOnSubscribe

15:10:05.681 [SUB-6] INFO reactor.Flux.Range.1 - | onSubscribe([Synchronous Fuseable] FluxRange.RangeSubscription)

15:10:05.687 [SUB-6] INFO reactor.Flux.Range.1 - | request(2)

15:10:05.688 [SUB-6] INFO reactor.Flux.Range.1 - | onNext(1)

15:10:05.718 [SUB-6] INFO schedule.ScheduleTest - map1: 1 --> 21

15:10:05.719 [SUB-6] INFO schedule.ScheduleTest - mapBySub: 21 --> 121

15:10:05.720 [SUB-6] INFO reactor.Flux.Range.1 - | onNext(2)

15:10:05.720 [SUB-6] INFO schedule.ScheduleTest - map1: 2 --> 22

15:10:05.720 [SUB-6] INFO schedule.ScheduleTest - mapBySub: 22 --> 122

15:10:05.721 [PUB1-5] INFO schedule.ScheduleTest - mapByPub1: 121 --> 1121

15:10:05.722 [PUB1-5] INFO schedule.ScheduleTest - mapByPub1: 122 --> 1122

15:10:05.734 [SUB-6] INFO reactor.Flux.Range.1 - | request(2)

15:10:05.735 [SUB-6] INFO reactor.Flux.Range.1 - | onNext(3)

15:10:05.735 [SUB-6] INFO schedule.ScheduleTest - map1: 3 --> 23

15:10:05.735 [SUB-6] INFO schedule.ScheduleTest - mapBySub: 23 --> 123

15:10:05.735 [SUB-6] INFO reactor.Flux.Range.1 - | onNext(4)

15:10:05.735 [SUB-6] INFO schedule.ScheduleTest - map1: 4 --> 24

15:10:05.735 [SUB-6] INFO schedule.ScheduleTest - mapBySub: 24 --> 124

15:10:05.736 [PUB2-4] INFO schedule.ScheduleTest - hookOnNext: 1121

15:10:05.736 [PUB2-4] INFO schedule.ScheduleTest - hookOnNext: 1122

15:10:05.736 [PUB1-5] INFO schedule.ScheduleTest - mapByPub1: 123 --> 1123

15:10:05.736 [PUB1-5] INFO schedule.ScheduleTest - mapByPub1: 124 --> 1124

15:10:05.736 [PUB2-4] INFO schedule.ScheduleTest - hookOnNext: 1123

15:10:05.736 [PUB2-4] INFO schedule.ScheduleTest - hookOnNext: 1124

15:10:05.736 [SUB-6] INFO reactor.Flux.Range.1 - | request(2)

15:10:05.736 [SUB-6] INFO reactor.Flux.Range.1 - | onNext(5)

15:10:05.736 [SUB-6] INFO schedule.ScheduleTest - map1: 5 --> 25

15:10:05.736 [SUB-6] INFO schedule.ScheduleTest - mapBySub: 25 --> 125

15:10:05.737 [SUB-6] INFO reactor.Flux.Range.1 - | onNext(6)

15:10:05.737 [PUB1-5] INFO schedule.ScheduleTest - mapByPub1: 125 --> 1125

15:10:05.737 [SUB-6] INFO schedule.ScheduleTest - map1: 6 --> 26

15:10:05.737 [SUB-6] INFO schedule.ScheduleTest - mapBySub: 26 --> 126

15:10:05.737 [PUB2-4] INFO schedule.ScheduleTest - hookOnNext: 1125

15:10:05.737 [PUB1-5] INFO schedule.ScheduleTest - mapByPub1: 126 --> 1126

15:10:05.737 [PUB2-4] INFO schedule.ScheduleTest - hookOnNext: 1126

15:10:05.737 [SUB-6] INFO reactor.Flux.Range.1 - | onComplete()

15:10:05.738 [PUB2-4] INFO schedule.ScheduleTest - hookOnComplete


실행 결과를 보면 첫 번째 publishOn()으로 PUB1 스케줄러를 지정하기 전까지는 SUB 스케줄러가 request 요청과 map1, mapBySub 변환을 처리하는 것을 확인할 수 있다.


[노트]

subscribeOn()이 publishOn() 뒤에 위치하면 실질적으로 prefetch할 때를 제외하면 적용되지 않는다. subscribeOn()은 원본 시퀀스의 신호 발생을 처리할 스케줄러를 지정하므로 시퀀스 생성 바로 뒤에 subscribeOn()을 지정하도록 하자. 또한 두 개 이상 subscribeOn()을 지정해도 첫 번째 subscribeOn()만 적용된다.


스케줄러 종류

스프링 리액터는 다음 스케줄러를 기본 제공한다.


  • Schedulers.immediate() : 현재 쓰레드에서 실행한다.
  • Schedulers.single() : 쓰레드가 한 개인 쓰레드 풀을 이용해서 실행한다. 즉 한 쓰레드를 공유한다.
  • Schedulers.elastic() : 쓰레드 풀을 이용해서 실행한다. 블로킹 IO를 리액터로 처리할 때 적합하다. 쓰레드가 필요하면 새로 생성하고 일정 시간(기본 60초) 이상 유휴 상태인 쓰레드는 제거한다. 데몬 쓰레드를 생성한다.
  • Schedulers.parallel() : 고정 크기 쓰레드 풀을 이용해서 실행한다. 병렬 작업에 적합하다.

single(), elastic(), parallel()은 매번 새로운 쓰레드 풀을 만들지 않고 동일한 쓰레드 풀을 리턴한다. 예를 들어 아래 코드에서 두 publishOn()은 같은 쓰레드 풀을 공유한다.


someFlux.publishOn(Schedulers.parallel())

            .map(...)

            .publishOn(Schedulers.parallel())

            .subscribe(...);


single(), elastic(), parallel()이 생성하는 쓰레드는 데몬 쓰레드로서 main 쓰레드가 종료되면 함께 종료된다.


같은 종류의 쓰레드 풀인데 새로 생성하고 싶다면 다음 메서드를 사용하면 된다.

  • newSingle(String name)
  • newSingle(String name, boolean daemon)
  • newElastic(String name)
  • newElastic(String name, int ttlSeconds)
  • newElastic(String name, int ttlSeconds, boolean daemon)
  • newParallel(String name)
  • newParallel(String name, int parallelism)
  • newParallel(String name, int parallelism, boolean daemon)

각 파라미터는 다음과 같다.

  • name : 쓰레드 이름으로 사용할 접두사이다.
  • daemon : 데몬 쓰레드 여부를 지정한다. 지정하지 않으면 false이다. 데몬 쓰레드가 아닌 경우 JVM 종료시에 생성한 스케줄러의 dispose()를 호출해서 풀에 있는 쓰레드를 종료해야 한다.
  • ttlSeconds : elastic 쓰레드 풀의 쓰레드 유휴 시간을 지정한다. 지정하지 않으면 60(초)이다.
  • parallelism : 작업 쓰레드 개수를 지정한다. 지정하지 않으면 Runtime.getRuntime().availableProcessors()이 리턴한 값을 사용한다.

newXXX() 로 생성하는 쓰레드 풀은 기본으로 데몬 쓰레드가 아니기 때문에 어플리케이션 종료시에는 다음과 같이 dispose() 메서드를 호출해서 쓰레드를 종료시켜 주어야 한다. 그렇지 않으면 어플리케이션이 종료되지 않는 문제가 발생할 수 있다.


// 비데몬 스케줄러 초기화

Scheduler scheduler = Schedulers.newElastic("SUB", 60, false);


// 비데몬 스케줄러 사용

someFlux.publishOn(scheduler)

            .map(...)

            .subscribe(...)


// 어플리케이션 종료시에 스케줄러 종료 처리

scheduler.dispose();


병렬 처리와 관련된 내용은 다음에 더 자세히 살펴본다.


일정 주기로 tick 발생: Flux.interval

Flux.interval()을 사용하면 일정 주기로 신호를 발생할 수 있다. 발생 순서에 따라 발생한 정수 값을 1씩 증가시킨다. 다음은 간단한 사용 예이다.


Flux.interval(Duration.ofSeconds(1)) // Flux<Long>

        .subscribe(tick -> System.out.println("Tick " + tick));


Thread.sleep(5000);


위 코드를 실행한 결과는 다음과 같다.

Tick 0
Tick 1
Tick 2
Tick 3
Tick 4


1초 간격으로 신호가 발생하는 것을 알 수 있다.


interval()은 Schedulers.parallel()를 사용해서 신호를 주기적으로 발생한다. 다른 스케줄러를 사용하고 싶다면 internval(Duration, Scheduler) 메서드를 사용하면 된다.


관련글

Posted by 최범균 madvirus

댓글을 달아 주세요

에러 처리

시퀀스는 데이터를 발생하는 과정에서 에러를 발생할 수 있다. 리액터는 에러를 처리하는 여러 방법을 제공하는데 이 글에서는 레퍼런스 문서에서 언급하는 에러 처리 방법을 차례대로 살펴볼 것이다.


참고로 에러 신호는 종료 신호이다. 따라서 에러 신호가 발생하면 시퀀스는 종료되고 더 이상 데이터를 발생하지 않는다.


에러 신호 처리

에러 신호가 발생하면 Subscriber의 onError 메서드가 호출된다. 이 메서드를 구현한 Subscriber를 이용해서 구독을 하면 에러 신호를 알맞게 처리할 수 있다. 또한 에러 처리를 위한 Consumber를 파라미터로 갖는 subscribe() 메서드를 사용해서 익셉션을 처리할 수 있다. 다음 코드는 에러 처리를 위한 Consumer를 파라미터로 갖는 subscribe() 메서드의 사용 예를 보여준다.


Flux.range(1, 10)

        .map(x -> {

            if (x == 5) throw new RuntimeException("exception"); // 에러 발생

            else return x;

        })

        .subscribe(

                i -> System.out.println(i), // next 신호 처리

                ex -> System.err.println(ex.getMessage()), // error 신호 처리

                () -> System.out.println("complete") // complete 신호 처리

        );


위 코드는 1부터 10개의 값을 발생하는데 값이 5이면 익셉션을 발생하는 시퀀스를 생성한다. subscribe() 메서드는 3개의 인자를 갖는데 차례대로 next, error, complete 신호를 처리한다. 실행 결과는 다음과 같다.


1

2

3

4

exception


에러 신호는 종료 신호이므로 익셉션 발생 이후에 더 이상 next 신호가 발생하지 않는 것을 확인할 수 있다.


에러 신호를 처리하기 위한 subscribe() 메서드는 다음과 같다.

  • subscribe(Consumer<? super T> consumer,
                    Consumer<? super Throwable> errorConsumer)
  • subscribe(Consumer<? super T> consumer,
                    Consumer<? super Throwable> errorConsumer,
                    Runnable completeConsumer)
  • subscribe(Consumer<? super T> consumer,
                    Consumer<? super Throwable> errorConsumer,
                    Runnable completeConsumer,
                    Consumer<? super Subscription> subscriptionConsumer)
  • subscribe(Subscriber<? super T> subscriber)


에러 발생하면 기본 값 사용하기: onErrorReturn

에러가 발생할 때 에러 대신에 특정 값을 발생하고 싶다면 onErrorReturn() 메서드를 사용한다. 이 메서드의 사용 예는 다음과 같다.


Flux<Integer> seq = Flux.range(1, 10)

        .map(x -> {

            if (x == 5) throw new RuntimeException("exception");

            else return x;

        })

        .onErrorReturn(-1);


seq.subscribe(System.out::println);


위 코드를 실행한 결과는 다음과 같다.


1

2

3

4

-1


실행 결과에서 알 수 있듯이 에러 대신에 값을 발생한 뒤에 시퀀스는 종료된다.


발생한 익셉션이 특정 조건을 충족하는 경우에만 에러 대신에 특정 값을 발생하고 싶다면 Predicate을 인자로 받는 onErrorReturn() 메서드를 사용한다. 익셉션이 특정 타입인 경우에만 에러 대신 특정 값을 발생하고 싶다면 Class 타입을 인자로 받는 onErrorReturn() 메서드를 사용한다.

  • Flux<T> onErrorReturn(Predicate<? super Throwable> predicate, T fallbackValue)
  • <E extends Throwable> Flux<T> onErrorReturn(Class<E> type, T fallbackValue)


에러 발생하면 다른 신호(시퀀스)나 다른 에러로 대체하기: onErrorResume

onErrorResume 메서드를 사용하면 에러가 발생하면 다른 시퀀스나 에러로 대체할 수 있다. onErrorResume 메서드는 다음 타입의 함수를 파라미터로 갖는다.

  • Function<? super Throwable, ? extends Publisher<? extends T>> :
    Throwable을 입력으로 받고 Publisher를 리턴하는 함수
이 함수는 시퀀스에서 발생한 에러를 입력으로 받아 결과로 Publisher를 리턴한다. 즉 에러가 발생하면 이를 다른 데이터 신호로 대체한다. 다음 코드를 보자.

Random random = new Random();
Flux<Integer> seq = Flux.range(1, 10)
        .map(x -> {
            int rand = random.nextInt(8);
            if (rand == 0) throw new IllegalArgumentException("illarg");
            if (rand == 1) throw new IllegalStateException("illstate");
            if (rand == 2) throw new RuntimeException("exception");
            return x;
        })
        .onErrorResume(error -> {
            if (error instanceof IllegalArgumentException) {
                return Flux.just(21, 22);
            }
            if (error instanceof IllegalStateException) {
                return Flux.just(31, 32);
            }
            return Flux.error(error);
        });

seq.subscribe(System.out::println);


이 코드에서 onErrorResume() 메서드에 전달한 함수를 보자. 이 함수는 발생한 에러가 IllegalArgumentException이면 Flux.just(21, 22)로 21, 22 값을 생성하는 시퀀스를 리턴하고, 발생한 에러가 IllegalStateException이면 31, 32 값을 생성하는 시퀀스를 리턴한다. 두 조건에 해당하지 않는 경우 Flux.error() 메서드를 이용해서 익셉션을 다시 재발생시킨다.


map() 함수에서 임의로 익셉션을 발생시키도록 했으므로 실행할 때마다 결과가 달라진다. 다음은 여러 번 실행한 결과 중 하나이다. 이 실행 결과는 3번째 데이터를 map에서 처리하는 과정에서 IllegalArgumentException이 발생했고 onErrorResume()을 통해 에러 대신에 21, 22를 생성하는 Flux로 대체된 것을 보여준다.


1

2

21

22


onErrorReturn과 마찬가지로 onErrorResume도 Predicate이나 Class 타입을 파라미터로 갖는 메서드를 이용해서 처리할 익셉션을 제한할 수 있다.


에러를 다른 에러로 변환하기: onErrorMap

에러를 다른 에러로 변환할 때에는 onErrorMap을 사용한다. 다음은 간단한 사용 예이다.


Flux<Integer> seq = intSeq.onErrorMap(error -> new MyException(...));


onErrorMap도 Predicate이나 Class 타입을 파라미터로 갖는 메서드를 이용해서 변환할 익셉션을 제한할 수 있다.


재시도하기: retry

retry()를 사용하면 에러가 발생했을 구독을 재시도할 수 있다. 다음은 예제 코드이다.


Flux.range(1, 5)

        .map(input -> {

            if (input < 4) return "num " + input;

            throw new RuntimeException("boom");

        })

        .retry(1) // 에러 신호 발생시 1회 재시도

        .subscribe(System.out::println, System.err::println);


위 코드를 실행한 결과는 다음과 같다.


num 1

num 2

num 3

num 1

num 2

num 3

java.lang.RuntimeException: boom


재시도를 하면 원본 시퀀스를 다시 구독한다. 이런 이유로 위 결과는 에러가 처음 발생했을 때 다시 1부터 신호가 발생하고 있다. 두 번째 에러가 발생했을 때에는 재시도를 하지 않으므로 에러 메시지가 출력되는 것을 알 수 있다.


재시도하기: retryWhen

단순 재시도가 아닌 조금 더 복잡한 상황에 따라 재시도를 하고 싶다면 retryWhen을 사용한다. retryWhen 메서드는 사용법이 다소 복잡하다. 먼저 retryWhen 메서드의 파라미터를 보자. 파라미터 타입은 다음과 같다.

  • retryWhen(Function< Flux<Throwable>,  ? extends Publisher<?> > whenFactory)
whenFactory 파라미터는 Function 타입의 함수이다. 이 함수는 입력으로 Flux<Throwable>를 받고 결과로 Publisher를 리턴한다. 여기서 whenFactory의 함수의 입력인 Flux<Throwable>는 시퀀스가 발생하는 익셉션 신호에 해당한다. 재시도 횟수에 따라 익셉션이 여러 번 발생할 수 있는데 Flux<Throwable>이 발생하는 데이터는 바로 여러 번 발생할 수 있는 익셉션에 해당한다.

whenFactory 함수에 전달되는 Flux<Throwable>은 원본 시퀀스의 익셉션과 연관되어 있으므로 이를 컴페니언(companion) Flux라고 부른다.

whenFactory 함수는 재시도 조건에 맞게 변환한 컴페니언 Flux를 리턴한다. 이 변환한 컴페니언 Flux가 재시도 여부를 결정하는데 그 과정은 다음과 같다.
  1. 에러가 발생할 때마다 에러가 컴페니언 Flux로 전달된다.
  2. 컴페니언 Flux가 뭐든 발생하면 재시도가 일어난다.
  3. 컴페니언 Flux가 종료되면 재시도를 하지 않고 원본 시퀀스 역시 종료된다.
  4. 컴페니언 Flux가 에러를 발생하면 재시도를 하지 않고 컴페니언 Flux가 발생한 에러를 전파한다.
위 설명만으로는 감이 잘 안 올 테니 간단한 예를 살펴보자. 먼저 다음은 2번 재시도하는 예제 코드이다.


Flux<Integer> seq = Flux.just(1, 2, 3)

        .map(i -> {

            if (i < 3) return i;

            else throw new IllegalStateException("force");

        })

        .retryWhen(errorsFlux -> errorsFlux.take(2)); // 2개의 데이터 발생


seq.subscribe(

        System.out::println,

        err -> System.err.println("에러 발생: " + err),

        () -> System.out.println("compelte")

);


위 코드에서 retryWhen은 take(2)를 사용해서 2개의 데이터를 발생하는 컴페니언 Flux를 리턴한다. 이 컴페니언 Flux는 2개의 데이터를 발생하고 종료된다. 즉 2-3번 과정에 의해 2번 재시도를 하고 원본 시퀀스를 종료시킨다. 실제 실행 결과는 다음과 같다. 괄호 안의 파란 글씨는 재시도 여부를 표시한 것으로 실제 출력에 포함된 내용은 아니다.


1

2

1    (1번 재시도)

2

1    (2번 재시도)

2

complete


출력 결과에서 눈여겨 볼 점은 에러가 출력되지 않았다는 점이다. 즉 컴페니언 Flux가 complete 신호를 보내면 Subscriber에도 complete 신호가 전달되고 있다. 이 점은 retry()와 다르다. retry()는 최대 재시도 이후에도 에러가 발생하면 해당 에러를 Subscriber에 전달하는데 retryWhen은 컴페니언 Flux가 어떤 데이터를 발생하느냐에 따라 에러를 Subscriber에 전달할지 여부가 달라진다.


다음 코드는 컴페니언 Flux가 에러를 발생하는 예이다.


Flux<Integer> seq = Flux.just(1, 2, 3)

        .map(i -> {

            if (i < 3) return i;

            else throw new IllegalStateException("force");

        })

        .retryWhen(errorsFlux -> errorsFlux.zipWith(Flux.range(1, 3),

                (error, index) -> {

                    if (index < 3) return index;

                    else throw new RuntimeException("companion error"); // 

                })

        );


seq.subscribe(

        System.out::println,

        err -> System.err.println("에러 발생: " + err),

        () -> System.out.println("compelte")

);


위 코드에서 retryWhen이 생성하는 컴페니언 Flux는 에러가 세 번째 발생하면 RuntimeException을 발생한다. 즉 두 번째 에러까지는 데이터 신호를 발생하고 세 번째 에러에 에러 신호를 발생한다. 따라서 두 번 재시도를 한다. 실행 결과는 다음과 같다.


1

2

1

2

1

2

에러 발생: java.lang.RuntimeException: companion error


실행 결과를 보면 두 번 재시도 후에 에러 신호를 받은 것을 알 수 있다.


관련 글


Posted by 최범균 madvirus

댓글을 달아 주세요

시퀀스 변환

이 글에서는 시퀀스가 발생하는 데이터를 변환하는 몇 가지 방법을 살펴본다.


1-1 변환: map

첫 번째는 map()이다. map() 한 개의 데이터를 1-1 방식으로 변환해준다. 자바 스트림의 map()과 유사하다. 다음 코드는 map()의 예를 보여준다.


Flux.just("a", "bc", "def", "wxyz")

        .map(str -> str.length()) // 문자열을 Integer 값으로 1-1 변환

        .subscribe(len -> System.out.println(len));


1-n 변환: flatMap

flatMap은 1개의 데이터로부터 시퀀스를 생성할 때 사용한다. 즉 1-n 방식의 변환을 처리한다. 다음은 간단한 flatMap() 사용 예이다.


Flux<Integer> seq = Flux.just(1, 2, 3)

             .flatMap(i -> Flux.range(1, i)) // Integer를 Flux<Integer>로 1-N 변환


seq.subscribe(System.out::println);


flatMap()에 전달한 함수를 보면 Integer 값을 받아서 다시 1부터 해당 값 개수만큼의 숫자를 생성하는 Flux를 생성한다. 위 코드를 보면 다음과 같은 변환이 발생한다.

  • 1 -> Flux.range(1, 1) : [1] 생성
  • 2 -> Flux.range(1, 2) : [1, 2] 생성
  • 3 -> Flux.range(1, 3) : [1, 2, 3] 생성
flatMap에 전달한 함수가 생성하는 각 Flux는 하나의 시퀀스처럼 연결된다. 그래서 flatMap()의 결과로 생성되는 Flux의 타입이 Flux<Flux<Integer>>가 아니라 Flux<Integer>이다.

실제 실행 결과는 다음과 같다.

1
1
2
1
2
3


걸러내기: filter

filter()를 이용해서 시퀀스가 생성한 데이터를 걸러낼 수 있다. filter()에 전달한 함수의 결과가 true인 데이터만 전달하고 false인 데이터는 발생하지 않는다. 다음은 1부터 10 사이의 숫자 중에서 2로 나눠 나머지가 0인 (즉 짝수인) 숫자만 걸러내는 예를 보여준다.


Flux.range(1, 10)

        .filter(num -> num % 2 == 0)

        .subscribe(x -> System.out.print(x + " -> "));


실행 결과는 다음과 같다.


2 -> 4 -> 6 -> 8 -> 10 -> 


빈 시퀀스인 경우 기본 값 사용하기: defaultIfEmpty

시퀀스에 데이터가 없을 때 특정 값을 기본으로 사용하고 싶다면 defaultIfEmpty() 메서드를 사용하면 된다. Mono와 Flux 모두 defaultIfEmpty()를 제공한다. 아래 코드는 사용 예이다.


Flux<Item> popularItems = getPopularItems();

Flux<Item> recItems = popularItems.defaultIfEmpty(featureItem);


getPopularItems() 메서드가 인기 상품 목록을 제공한다고 하자. 이 코드는 인기 상품 목록을 제공하는 시퀀스인 popularItems가 데이터가 없는 빈 시퀀스면 featureItem을 값으로 제공하는 Flux로 변환한다. 즉 인기 상품이 있으면 그 상품 목록을 제공하고 그렇지 않으면 미리 지정한 featureItem을 값으로 제공하는 Flux를 생성한다.


위 코드를 조금 더 간결하게 표현하면 다음과 같다.


Flux<Item> recItems = getPopularItems().defaultIfEmpty(featureItem);


빈 시퀀스인 경우 다른 시퀀스 사용하기: switchIfEmpty

시퀀스에 값이 없을 때 다른 시퀀스를 사용하고 싶다면 switchIfEmpty() 메서드를 사용한다.


// public Flux<Item> getPopularItems() { ... }

// public Flux<Item> getFeatureItems() { ... }


Flux<Item> recItems = 

    getPopularItems().switchIfEmpty(getFeatureItems());



특정 값으로 시작하는 시퀀스로 변환: startWith

특정 값으로 시작하도록 시퀀스를 설정하고 싶다면 startWith(T ...) 메서드나 startWith(시퀀스) 메서드를 사용한다.


Flux<Integer> seq1 = Flux.just(1, 2, 3);


Flux<Integer> seq2 = seq1.startWith(-1, 0);

seq2.subscribe(System.out::println);


이 코드에서 seq1은 1, 2, 3을 생성하는 시퀀스인데 startWith(-1, 0)을 사용해서 -1, 0으로 시작하는 시퀀스로 변환했다. 따라서 seq2가 생성하는 데이터는 -1, 0, 1, 2, 3이 된다.


특정 값으로 끝나는 시퀀스로 변환: concatWithValues

시퀀스가 특정 값으로 끝나도록 변환하고 싶다면 concatWithValues(T ...) 메서드를 사용한다.


Flux<Integer> seq = someSeq.concatWithValues(100);

seq.subscribe(System.out::println);


위 코드는 someSeq가 어떤 값을 생성하는지에 상관없이 seq는 가장 마지막에 100을 생성한다.


시퀀스 순서대로 연결: cancatWith

concatWith() 메서드를 사용하면 여러 시퀀스를 순서대로 연결할 수 있다.


Flux<Integer> seq1 = Flux.just(1, 2, 3);

Flux<Integer> seq2 = Flux.just(4, 5, 6);

Flux<Integer> seq3 = Flux.just(7, 8, 9);


seq1.concatWith(seq2).concatWith(seq3).subscribe(System.out::println);


위 코드에서 seq1, seq2, seq3을 차례대로 연결하고 구독을 시작했다. 실행 결과는 1부터 9까지 정수를 출력한다.


concatWith로 연결한 시퀀스는 이전 시퀀스가 종료된 뒤에 구독을 시작한다. 위 예에서는 seq1이 종료된 뒤에 seq2 구독을 시작하고 seq2가 종료된 뒤에 seq3 구독을 시작한다.


시퀀스 발생 순서대로 섞기: mergeWith

시퀀스의 연결 순서가 아니라 시퀀스가 발생하는 데이터 순서대로 섞고 싶다면 mergeWith()를 사용한다. 다음은 예이다.


Flux<String> tick1 = Flux.interval(Duration.ofSeconds(1)).map(tick -> tick + "초틱");

Flux<String> tick2 = Flux.interval(Duration.ofMillis(700)).map(tick -> tick + "밀리초틱");

tick1.mergeWith(tick2).subscribe(System.out::println);


위 코드에서 tick1은 1초 간격으로 데이터를 발생하고 tick2는 700 밀리초 단위로 데이터를 발생한다. 이 두 시퀀스를 mergeWith()로 섞은 뒤 구독하면 두 시퀀스를 동시에 구독한다. 실행 결과는 다음과 같다.


0밀리초틱

0초틱

1밀리초틱

1초틱

2밀리초틱

3밀리초틱

2초틱

4밀리초틱

3초틱

5밀리초틱

...


다음은 실행 결과를 발생 시점 기준으로 그림으로 표시한 것이다. 1초 간격으로 데이터를 발생하는 seq1과 0.7초 간격으로 데이터를 발생하는 seq2를 mergeWith()로 섞을 때 데이터 발생 순서를 알 수 있다.





시퀀스 묶기: zipWith

zipWith()를 사용하면 두 시퀀스의 값을 묶은 값 쌍을 생성하는 시퀀스를 생성할 수 있다. 다음은 사용 예이다.


Flux<String> tick1 = Flux.interval(Duration.ofSeconds(1)).map(tick -> tick + "초틱");

Flux<String> tick2 = Flux.interval(Duration.ofMillis(700)).map(tick -> tick + "밀리초틱");

tick1.zipWith(tick2).subscribe(tup -> System.out.println(tup));


zipWith()는 개수를 맞춰서 두 시퀀스의 데이터를 묶는다. 따라서 위 코드는 아래 그림과 같이 쌍을 묶는다.


zipWith()는 리액터에 포함된 Tuple2 타입을 이용해서 두 값을 쌍으로 묶는다. 위 코드의 실행 결과는 아래와 같다.

[0초틱,0밀리초틱]
[1초틱,1밀리초틱]
[2초틱,2밀리초틱]
[3초틱,3밀리초틱]
[4초틱,4밀리초틱]

시퀀스 묶기: combineLatest


Flux.combineLatest() 메서드로 시퀀스를 묶을 수도 있다. 이 메서드 정적 메서드이다. 발생한 개수를 맞춰서 쌍을 만드는 zipWith()와 달리 combineLatest()는 가장 최근의 데이터를 쌍으로 만든다. 다음은 그 차이를 보여준다.



다음은 예제 코드이다.


Flux<String> tick1 = Flux.interval(Duration.ofSeconds(1)).map(tick -> tick + "초틱");

Flux<String> tick2 = Flux.interval(Duration.ofMillis(700)).map(tick -> tick + "밀리초틱");

Flux.combineLatest(tick1, tick2, (a, b) -> a + "\n" + b).subscribe(System.out::println);


지정한 개수/시간에 해당하는 데이터만 유지: take, takeLast

시퀀스에서 처음 n개의 데이터만 유지하고 싶다면 take(long) 메서드를 사용한다. 비슷하게 지정한 시간 동안 발생한 데이터만 유지하고 싶다면 take(Duration) 메서드를 사용한다. 마지막 n개의 데이터만 유지하고 싶다면 takeLast(long) 메서드를 사용한다.

Flux<Integer> seq1 = someSeq.take(10); // 최초 10개 데이터만 유지
Flux<Integer> seq2 = someSeq.take(Duration.ofSeconds(10)); // 최초 10초 동안 데이터 유지
Flux<Integer> seq3 = someSeq.takeLast(5); // 마지막 5개 데이터만 유지

이 외에 takeWhile()과 takeUntil()도 있다. 이 두 메서드는 Predicate을 인자로 받는다. takeWhile()은 Predicate 구현이 true를 리턴하는 동안 데이터를 포함하고 takeUntil()은 처음 true를 리턴할 때까지 데이터를 포함한다.

지정한 개수/시간만큼 데이터 거르기: skip, skipLast

시퀀스에서 처음 n개의 데이터를 거르고 싶다면 skip(long) 메서드를 사용한다. 지정한 처음 시간 동안 발생한 데이터를 거르고 싶다면 skip(Duration) 메서드를 사용한다. 마지막 n개의 데이터를 거르고 싶다면 skipLast(long) 메서드를 사용한다.

take()와 비슷하게 skipWhile()과 skipUntil()을 지원한다.


관련 글


Posted by 최범균 madvirus

댓글을 달아 주세요

시퀀스 생성 2: Flux.create(), Flux.fromStream()

이전 글(스프링 리액터 시작하기 2 - 시퀀스 생성 just, generate)에서 살펴본 Flux.generate()는 Subscriber로부터 요청이 있을 때에 next 신호를 발생하는 Flux를 생성한다. 즉 pull 방식의 Flux를 생성한다. 이는 단순하지만 데이터 발생을 비동기나 push 방식으로 할 수 없다는 제약도 있다. Flux.create()를 사용하면 이런 제약 없이 비동기나 push 방식으로 데이터를 발생할 수 있다.


Flux.create()를 이용한 pull 방식 메시지 생성

먼저 Flux.create() 메서드를 이용해서 pull 방식으로 메시지를 생성하는 방법을 살펴보자. 다음은 예제 코드이다.


Flux<Integer> flux = Flux.create( (FluxSink<Integer> sink) -> {

    sink.onRequest(request -> { // request는 Subscriber가 요청한 데이터 개수

        for (int i = 1; i <= request; i++) {

            sink.next(i); // Flux.generate()의 경우와 달리 한 번에 한 개 이상의 next() 신호 발생 가능

        }

    });

});


위 코드에서 Flux.create() 메서드의 파라머티는 함수형 타입 Consumer<? super FluxSink<T>>이다. 이 Consumer는 FluxSink를 이용해서 Subscriber에 신호를 발생할 수 있다.


FluxSink#onRequest(LongConsumer) 메서드의 Consumer는 Subscriber가 데이터를 요청했을 때 불린다. 이때 LongConsumer는 Subscriber가 요청한 데이터 개수를 전달받는다. 위 코드에서는 클라이언트가 요청한 데이터 개수만큼 next 신호를 발생하고 있다.


Flux.generate()와의 차이점은 Flux.generate()의 경우 한 번에 한 개의 next 신호만 발생할 수 있었던 데 비해 Flux.create()는 한 번에 한 개 이상의 next() 신호를 발생할 수 있다는 점이다.


Flux.create()를 이용한 push 방식 메시지  생성

Flux.create()를 이용하면 Subscriber의 요청과 상관없이 비동기로 데이터를 발생할 수 있다. 다음 코드를 보자.


DataPump pump = new DataPump();


Flux<Integer> bridge = Flux.create((FluxSink<Integer> sink) -> {

    pump.setListener(new DataListener<Integer>() {

        @Override

        public void onData(List<Integer> chunk) {

            chunk.forEach(s -> {

                sink.next(s); // Subscriber의 요청에 상관없이 신호 발생

            });

        }

        @Override

        public void complete() {

            logger.info("complete");

            sink.complete();

        }

    });

});


이 코드에서 DataPump는 데이터를 어딘가에서 데이터가 오면 setListener()로 등록한 DataListener의 onData()를 실행한다고 가정하자. DataListener#onData() 메서드는 FluxSink#next()를 이용해서 데이터를 발생한다. DataListener#onData() 메서드는 Subscriber의 데이터 요청과 상관없이 호출된다. 즉 위 코드는 Subscriber의 요청과 상관없이 데이터를 push한다.


Flux.create()와 배압

Subscriber로부터 요청이 왔을 때(FluxSink#onRequest) 데이터를 전송하거나(pull 방식) Subscriber의 요청에 상관없이 데이터를 전송하거나(push 방식) 두 방식 모두 Subscriber가 요청한 개수보다 더 많은 데이터를 발생할 수 있다. 예를 들어 아래 코드를 보자.


Flux<Integer> flux = Flux.create( (FluxSink<Integer> sink) -> {

    sink.onRequest(request -> {

        for (int i = 1; i <= request + 3 ; i++) { // Subscriber가 요청한 것보다 3개 더 발생

            sink.next(i);

        }

    });

});


이 코드는 Subscriber가 요청한 개수보다 3개 데이터를 더 발생한다. 이 경우 어떻게 될까? 기본적으로 Flux.create()로 생성한 Flux는 초과로 발생한 데이터를 버퍼에 보관한다. 버퍼에 보관된 데이터는 다음에 Subscriber가 데이터를 요청할 때 전달된다.


요청보다 발생한 데이터가 많을 때 선택할 수 있는 처리 방식은 다음과 같다.

  • IGNORE : Subscriber의 요청 무시하고 발생(Subscriber의 큐가 다 차면 IllegalStateException 발생)
  • ERROR : 익셉션(IllegalStateException) 발생
  • DROP : Subscriber가 데이터를 받을 준비가 안 되어 있으면 데이터 발생 누락
  • LATEST : 마지막 신호만 Subscriber에 전달
  • BUFFER : 버퍼에 저장했다가 Subscriber 요청시 전달. 버퍼 제한이 없으므로 OutOfMemoryError 발생 가능

Flux.create()의 두 번째 인자로 처리 방식을 전달하면 된다.


Flux.create(sink -> { ... }, FluxSink.OverflowStrategy.IGNORE);


Flux.fromStream(), Flux.fromIterable()을 이용한 Flux 생성

Flux.stream()을 사용하면 자바 8의 Stram에서 Flux를 생성할 수 있다. 다음은 예이다.


Stream<String> straem = Files.lines(Paths.get(filePath));

Flux<String> seq = Flux.fromStream(straem);

seq.subscribe(System.out::println);


Flux.fromIterable()을 이용하면 Iterable을 이용해서 Flux를 생성할 수 있다. List나 Set과 같은 콜렉션에서 Flux를 생성하고 싶을 때 이 메서드를 사용하면 된다.


관련 글





Posted by 최범균 madvirus

댓글을 달아 주세요

시퀀스 생성 1 :just(), generate()

[노트]

시퀀스를 직접 생성할 일이 많지는 않다. 보통은 라이브러리가 제공하는 기능을 사용하기 때문이다. 그럼에도 불구하고 시퀀스 생성 방법을 정리한 이유는 리액터 시퀀스를 생성하는 방법을 살펴보면 리액티브의 동작을 이해하는데 도움이 되기 때문이다.


Flux.just(), Mono.just()로 만들기

시퀀스를 생성하는 가장 쉬운 방법은 Flux.just()를 사용하는 것이다. just() 메서드는 시퀀스로 사용할 데이터가 이미 존재할 때 사용한다. 다음은 사용 예이다.


Flux<Integer> seq = Flux.just(1, 2, 3);


이 Flux는 1, 2, 3 데이터를 차례대로 발생하고 complete 신호를 발생한다. just() 메서드는 가변 인자로 0개 이상의 데이터를 전달할 수 있다. 아래와 같이 발생할 데이터를 주지 않으면 complete 신호만 발생한다.


Flux<Integer> seq = Flux.just();


Mono.just()도 동일하다. 차이라면 Mono는 1개 값만 생성하므로 데이터도 한 개만 받는다는 것이다.


Mono<Integer> seq = Mono.just(1);


Mono.just(null)과 같이 null을 값으로 주면 NullPointerException이 발생한다. 데이터를 발생하지 않는 Mono를 생성하고 싶다면 Mono.empty()를 사용한다.


값이 있을 수도 있고 없을 수도 있는 Mono를 생성할 때에는 justOrEmpty() 메서드를 사용하면 된다. 다음은 사용 예이다.


// null을 값으로 받으면 값이 없는 Mono

Mono<Integer> seq1 = Mono.justOrEmpty(null); // complete 신호

Mono<Integer> seq2 = Mono.justOrEmpty(1); // next(1) 신호- complete 신호


// Optional을 값으로 받음

Mono<Integer> seq3 = Mono.justOrEmpty(Optional.empty()); // complete 신호

Mono<Integer> seq4 = Mono.justOrEmpty(Optional.of(1)); // next(1) 신호 - complete 신호


Flux.range()로 정수 생성하기

Flux.range() 메서드를 사용하면 순차적으로 증가하는 Integer를 생성하는 Flux를 생성할 수 있다. 예를 들어 다음 코드는 11부터 시작해서 5개의 Integer를 생성하는 Flux 시퀀스를 생성한다. 즉 11부터 15까지의 Integer를 생성한다.


Flux<Integer> seq = Flux.range(11, 5);


Flux.generate() 메서드로 Flux 만들기

Flux.generate() 메서드를 사용하면 데이터를 함수를 이용해서 생성할 수 있다. Flux.generate() 함수는 동기 방식으로 한 번에 1개의 데이터를 생성할 때 사용한다. Flux.generate() 메서드 중 하나는 다음과 같다.

  • Flux<T> generate(Consumer<SynchronousSink<T>> generator)
generator는 Subscriber로부터 요청이 왔을 때 신호를 생성한다. generate()가 생성한 Flux는 다음과 같은 방식으로 신호를 발생한다.
  • Subscriber의 요청에 대해 인자로 전달받은 generator를 실행한다. generator를 실행할 때 인자로 SynchronousSink를 전달한다.
  • generator는 전달받은 SynchronousSink를 사용해서 next, complete, error 신호를 발생한다. 한 번에 1개의 next() 신호만 발생할 수 있다.
예제 코드를 보자

Consumer<SynchronousSink<Integer>> randGen = new Consumer<>() {
    private int emitCount = 0;
    private Random rand = new Random();

    @Override
    public void accept(SynchronousSink<Integer> sink) {
        emitCount++;
        int data = rand.nextInt(100) + 1; // 1~100 사이 임의 정수
        logger.info("Generator sink next " + data);
        sink.next(data); // 임의 정수 데이터 발생
        if (emitCount == 10) { // 10개 데이터를 발생했으면
            logger.info("Generator sink complete");
            sink.complete(); // 완료 신호 발생
        }
    }
};

Flux<Integer> seq = Flux.generate(randGen);

seq.subscribe(new BaseSubscriber<>() {
    private int receiveCount = 0;
    @Override
    protected void hookOnSubscribe(Subscription subscription) {
        logger.info("Subscriber#onSubscribe");
        logger.info("Subscriber request first 3 items");
        request(3);
    }

    @Override
    protected void hookOnNext(Integer value) {
        logger.info("Subscriber#onNext: " + value);
        receiveCount++;
        if (receiveCount % 3 == 0) {
            logger.info("Subscriber request next 3 items");
            request(3);
        }
    }

    @Override
    protected void hookOnComplete() {
        logger.info("Subscriber#onComplete");
    }
});.

randGen의 accept() 메서드는 1~100 사이의 임의 정수를 생성한 뒤 인자로 SynchronousSink의 next() 메서드를 이용해서 next 신호를 발생한다. emitCount가 10이면(즉 데이터를 10개 발생했다면) SynchronousSink#complete() 메서드를 이용해서 complete 신호를 발생한다.

randGen은 신호 발생 기능을 제공할 뿐이며 실제 시퀀스는 Flux.generate()를 이용해서 생성했다.

seq.subscribe() 메서드에 전달한 Subscriber는 구독 시점에 3개의 데이터를 요청하고(hookOnSubscribe() 메서드의 request(3) 코드), 데이터를 3개 수신할 때마다 다시 3개의 데이터를 요청한다(hookOnNext() 메서드의 request(3) 코드).

콘솔에 관련 문장을 출력해서 실행 흐름을 알 수 있도록 했다. 위 코드를 실제로 실행해보면 다음 내용이 콘솔에 출력된다. 원래 출력에는 빈 줄이 없는데 쉬운 구분을 위해 빈 줄을 넣었고 Subscriber의 출력은 파란색으로 표시했다.

Subscriber#onSubscribe
Subscriber request first 3 items

Generator sink next 17
Subscriber#onNext: 17
Generator sink next 83
Subscriber#onNext: 83
Generator sink next 53
Subscriber#onNext: 53
Subscriber request next 3 items

Generator sink next 12
Subscriber#onNext: 12
Generator sink next 38
Subscriber#onNext: 38
Generator sink next 90
Subscriber#onNext: 90
Subscriber request next 3 items

Generator sink next 23
Subscriber#onNext: 23
Generator sink next 70
Subscriber#onNext: 70
Generator sink next 76
Subscriber#onNext: 76
Subscriber request next 3 items

Generator sink next 52
Subscriber#onNext: 52
Generator sink complete
Subscriber#onComplete

Flux가 제공하는 다른 generate() 메서드로는 다음이 있다.
  • Flux<T> generate(Callable<S> stateSupplier, BiFunction<S, SynchronousSink<T>, S> generator)
  • Flux<T> generate(Callable<S> stateSupplier, BiFunction<S, SynchronousSink<T>, S> generator,
                                 Consumer<? super S> stateConsumer)
stateSupplier는 값을 생성할 때 사용할 최초 상태이다. BiFunction 타입의 generator는 인자로 상태와 SynchronousSink를 입력받아 결과로 다음 상태를 리턴하는 함수이다. 앞서 예제와 마찬가지로 SynchronousSink를 사용해서 신호를 생성한다. 두 번째 generate() 메서드의 stateConsumer는 상태를 정리할 때 사용한다. generator가 complete 신호나 error 신호를 발생하면 상태 정리를 위해 stateConsumer를 실행한다.

다음은 상태를 사용하는 Flux.generate()를 이용해서 임의 숫자 10개를 발생시키는 Flux를 생성하는 코드 예이다.

Flux<String> flux = Flux.generate(
        () -> { // Callable<S> stateSupplier
            return 0;
        },
        (state, sink) -> { // BiFunction<S, SynchronousSink<T>, S> generator
            sink.next("3 x " + state + " = " + 3 * state);
            if (state == 10) {
                sink.complete();
            }
            return state + 1;
        });

이 코드에서 flux는 "3 x 1 = 3" 부터 "3 x 10 = 10" 까지의 데이터를 담은 next 신호를 차례대로 발생하고 state 값이 10이 되면 compelete 신호를 발생한다.

Flux.just()나 Flux.generate()는 데이터 생성 과정 자체가 동기 방식이다. Subscriber로부터 데이터 요청이 오면 그 시점에 SynchronousSink를 이용해서 데이터를 생성한다. 반면에 별도 쓰레드를 이용해서 비동기로 데이터를 생성해야 하는 경우에는 SynchronousSink를 사용할 수 없다. 게다가 SynchronousSink는 한 번에 하나의 next 신호만 발생할 수 있다. 예를 들어 아래 코드는 에러를 발생한다.


Flux<String> flux = Flux.generate(

        () -> 1,

        (state, sink) -> {

            sink.next("Q: 3 * " + state);

            sink.next("A: " + (3 * state)); // 에러!

            if (state == 10) {

                sink.complete();

            }

            return state + 1;

        });


데이터 자체를 비동기로 생성해야 하거나 번에 다수의 next 신호를 발생해야 할 경우 Flux.generate()로는 처리할 수 없다. 이 때에는 Flux.create() 메서드를 사용해야 하는데 이 메서드를 포함한 Flux를 생성하는 또 다른 방법은 다음 글에서 이어서 살펴본다.


관련 글


Posted by 최범균 madvirus

댓글을 달아 주세요

리액티브 스트림즈, Flux, Mono

스프링은 웹 요청 처리, HTTP 클라이언트, NoSQL 연동 등 많은 영역에서 리액티프 프로그래밍을 지원하고 있다. 스프링 리액터는 스프링에서 리액티브 프로그래밍을 위한 핵심 모듈이다. 리액터를 잘 사용하려면 많은 것들을 알아야 하지만 가장 기본이 되는 두 타입인 Flux와 Mono에 대해 알아야 한다. 이 글에서는 리액티브 프로그래밍의 핵심 개념인 스프림에 대해 살펴보고 Flux와 Mono의 기본적인 사용법을 살펴본다.


왜 리액티브인가?

서버 관점에서 리액티브를 사용하는 이유 중 하나는 비동기/논블록을 이용해서 더 적은 자원으로 더 많은 트래픽을 처리하기 위함이다. 관련 내용은 "왜 리액티브인가 요약" 글을 참고한다.


리액티브 스트림

리액티브 스트림즈(http://www.reactive-streams.org/)는 비동기 스트림 처리를 위한 표준이다. 스프링 리액터는 이를 구현한 라이브러리이며 자바9의 Flow API도 리액티브 스트림 API를 따르고 있다. 


스트림은 시간이 지남에 따라 생성되는 일련의 데이터/이벤트(event)/신호(signal)이다. 맥락에 따라 데이터, 이벤트, 신호라는 용어를 사요한다. 이 글에서도 필요에 따라 이들 용어를 혼용해서 사용할 것이다. 리액티브 스트림즈 스펙에서는 용어로 신호를 사용한다. 리액티브 스트림즈는 다음 세 신호를 발생할 수 있다.

  • onNext* (onComplete | onError)?

스트림은 0개 이상의 next 신호를 발생할 수 있다. next 신호는 데이터를 담는다. complete 신호는 스트림이 끝났음을 의미하며 error 신호는 에러가 발생했음을 의미한다. complete와 error는 둘 중 하나만 발생할 수 있으며, 이 두 신호는 발생하지 않을 수도 있다. 


스트림의 예로 1분 간격 현재 기온 스트림을 들 수 있다. 이 데이터는 개념적으로 complete나 error 없이 next 신호만 1분 간격으로 발생한다. 파일 스트림은 파일을 읽는 동안 데이터를 담은 next 신호를 발생하고 파일을 다 읽으면 compelete 신호를 발생한다. 파일을 읽는 도중 에러가 발생하면 error 신호를 발생한다.


리액티브 스트림즈는 Publisher를 이용해서 스트림을 정의하며 Subscriber를 이용해서 발생한 신호를 처리한다. Subscriber가 Publisher로부터 신호를 받는 것을 구독이라고 한다. 다음 코드는 스프링 리액터가 제공하는 Publisher의 한 종류인 Flux에 대해 구독하는 코드 예를 보여준다.


Flux<Integer> seq = Flux.just(1, 2, 3); // Integer 값을 발생하는 Flux 생성


seq.subscribe(value -> System.out.println("데이터 : " + value)); // 구독


리액터는 스트림이라는 용어 대신 시퀀스라는 용어를 주로 사용한다. 위 코드에서 변수 이름이 seq인 이유는 시퀀스를 의미하기 위함이다. 첫 줄은 1, 2, 3 값을 차례대로 발생하는 Flux를 생성한다.


실제 값 발생은 구독(subscription) 시점에 이뤄진다. 위 코드는 Flux#subscribe(Consumer) 메서드를 이용해서 구독한다. 이 경우 Flux가 발생한 신호를 Consumer가 받아서 처리한다. 위 코드는 수신한 데이터를 콘솔에 출력하므로 위 코드를 실행하면 다음과 같은 결과가 출력된다.


데이터 : 1

데이터 : 2

데이터 : 3


물론 이렇게 단순한 작업을 하기 위해 리액티브 프로그래밍을 사용하는 것은 아니다. 스케줄링, 다양한 조합 기능을 이용해서 이전보다 더 간결하면서도 자원을 효율적으로 사용하는 코드를 작성할 수 있다.


[노트]

리액티브 스트림즈는 스트림이라는 표현을 사용하지만 이는 자바 8의 스트림과 혼동할 수 있다. 이런 이유로 "리액티브 스트림즈" 자체를 표현할 때가 아니면 스트림 대신 시퀀스라는 용어를 사용하겠다.


리액터 사용 위한 메이븐 설정

리액터는 reactor-core, reactor-netty, reactor-extra, reactor-adapter 등 다양한 모듈로 구성되어 있다. 각 모듈의 버전을 맞추기 위해 리액터는 메이븐 BOM(Bill Of Materials)을 제공한다. 이 글에서는 reactor-core 의존만 사용하긴 하지만 BOM을 포함한 의존 설정을 사용해보자. 메이븐 의존 설정은 다음과 같다.


<dependencyManagement>

    <dependencies>

        <dependency>

            <groupId>io.projectreactor</groupId>

            <artifactId>reactor-bom</artifactId>

            <version>Bismuth-SR9</version>

            <type>pom</type>

            <scope>import</scope>

        </dependency>

    </dependencies>

</dependencyManagement>


<dependencies>

    <dependency>

        <groupId>io.projectreactor</groupId>

        <artifactId>reactor-core</artifactId>

    </dependency>


    <dependency>

        <groupId>org.slf4j</groupId>

        <artifactId>slf4j-api</artifactId>

        <version>1.7.12</version>

    </dependency>

    <dependency>

        <groupId>ch.qos.logback</groupId>

        <artifactId>logback-classic</artifactId>

        <version>1.2.3</version>

    </dependency>

</dependencies>


reactor-bom의 Bismuth 버전은 스프링 리액터 3.1 버전을 정의한다. Bismuth-SR9 버전은 reactor-core 3.1.7.RELEASE를 기준으로 한다.


스프링 리액터의 Publisher: Flux와 Mono

스프링 리액터는 Flux와 Mono의 두 가지 Publisher를 제공하고 있다. 이 두 타입은 발생할 수 있는 데이터 개수에 차이가 있다. Flux는 0개 이상의 데이터를 발생할 수 있고 Mono는 0 또는 1개의 데이터를 발생할 수 있다.


앞서 Publisher는 next, complete, error 신호를 발생할 수 있다고 했다. Flux는 0개 이상의 데이터를 발생하므로 0개 이상의 next 신호를 발생할 수 있고 complete나 error 신호를 발생하거나 발생하지 않을 수 있다. 예를 들어 다음 코드를 보자.


Flux.just(1, 2, 3);


이 코드에서 seq 시퀀스는 1, 2, 3을 값으로 갖는 세 개의 next 신호를 발생하고 마지막에 complete 신호를 발생해서 시퀀스를 끝낸다. 즉 시간 순으로 표시하면 다음과 같이 시퀀스가 발생한다('--->'는 시간축, '|'는 complete 신호 의미).


--1-2-3-|-->


아래 코드와 같이 아무 값도 발생하지 않는 시퀀스는 complete 신호만 발생한다.


Flux.just(); // --|-->


Mono도 유사하다. 차이라면 최대 발생할 수 있는 값이 1개라는 점이다.


Mono.just(1); // --1-|-->

Mono.empty(); // --|-->


just() 메서드는 이미 존재하는 값을 사용해서 Flux/Mono를 생성할 때 사용된다. just() 외에 create(), generate()를 이용해서 생성할 수 있는데 이에 대한 내용은 나중에 정리해보겠다.


[노트]

Flux와 Mono를 직접 생성하기보다는 다른 라이브러리가 제공하는 Flux와 Mono를 사용할 때가 많다. 예를 들어 스프링 5 버전에 추가된 WebClient 클래스를 사용할 때에는 WebClient가 생성하는 Mono를 이용해서 데이터를 처리한다.


구독과 신호 발생

시퀀스는 바로 신호를 발생하지 않는다. 구독을 하는 시점에 신호를 발생하기 시작한다. 코드로 확인해보자. 먼저 다음 코드를 보자.


Flux.just(1, 2, 3)

     .doOnNext(i -> System.out.println("doOnNext: " + i))

     .subscribe(i -> System.out.println("Received: " + i));


위 코드에서 doOnNext() 메서드는 Flux가 Subscriber에 next 신호를 발생할 때 불린다. 실행 결과는 다음과 같다.


doOnNext: 1

Received: 1

doOnNext: 2

Received: 2

doOnNext: 3

Received: 3


이제 코드를 다음과 같이 바꾸고 다시 실행해보자.


Flux<Integer> seq = Flux.just(1, 2, 3)

        .doOnNext(i -> System.out.println("doOnNext: " + i));


System.out.println("시퀀스 생성");

seq.subscribe(i -> System.out.println("Received: " + i));


실행 결과는 다음과 같다.


시퀀스 생성

doOnNext: 1

Received: 1

doOnNext: 2

Received: 2

doOnNext: 3

Received: 3


이 결과를 보면 시퀀스를 생성한 시점에는 doOnNext에 전달한 함수가 실행되지 않는 것을 알 수 있다. doOnNext에 전달한 함수는 next 신호를 발생할 때 호출되기 때문이다. subscribe()를 실행해서 구독을 한 이후에 doOnNext에 전달한 코드가 실행되는데 이는 subscribe() 시점에 신호를 발생하기 시작한다는 것을 보여준다.


콜드 시퀀스 vs 핫 시퀀스

시퀀스는 구독 시점부터 데이터를 새로 생성하는 콜드(cold) 시퀀스와 구독자 수에 상관없이 데이터를 생성하는 핫(hot) 시퀀스로 나뉜다.


앞 예제 Flux.just()로 생성한 시퀀스가 콜드 시퀀스이다. 콜드 시퀀스는 구독을 하지 않으면 데이터를 생성하지 않는다. 구독을 하면 그 시점에 데이터를 새롭게 발생한다. 다음 코드는 이런 특징을 보여준다.


Flux<Integer> seq = Flux.just(1, 2, 3);

seq.subscribe(v -> System.out.println("구독1: " + v)); // 구독

seq.subscribe(v -> System.out.println("구독2: " + v)); // 구독


이 코드는 seq 시퀀스에 대해 구독을 두 번한다. 코드 결과는 다음과 같은데 이 결과를 보면 seq 시퀀스는 각 구독마다 데이터를 새롭게 생성하는 것을 알 수 있다.


구독1: 1

구독1: 2

구독1: 3

구독2: 1

구독2: 2

구독2: 3


콜드 시퀀스의 예로 API 호출을 들 수 있다. API 호출 시퀀스는 구독을 할 때마다 매번 새로운 요청을 서버에 전송하고 결과를 받는다.


핫 시퀀스는 구독 여부에 상관없이 데이터가 생성된다. 구독을 하면 구독한 시점 이후에 발생하는 데이터부터 신호를 받는다. 콜드 스트림의 예로 센서 데이터를 들 수 있다. 센서 데이터를 제공하는 시퀀스스에 구독을 하면 그 시점 이후에 센서가 발생한 데이터부터 받게 된다.


Subscriber와 Subscription

앞 코드 예에서 다음의 subscribe() 메서드를 사용해서 구독을 했다.


// Flux나 Mono

subscribe(Consumer<? super T> consumer)


Consumer를 파라미터로 갖는 subscribe() 메서드는 리액터가 편의를 위해 제공하는 메서드로서 이 메서드는 내부적으로 Subscriber를 인자로 받는 subscribe() 메서드를 실행한다.


Subscriber는 리액티브 스트림즈에 포함된 인터페이스로 다음과 같이 정의되어 있다.


package org.reactivestreams;


public interface Subscriber<T> {

    void onSubscribe(Subscription s);

    void onNext(T t);

    void onError(Throwable t);

    void onComplete();

}


각 메서드는 다음과 같다.

  • onSubscribe(Subscription s): 구독을 하면 Publisher와 연동된 Subscription을 받는다. 전달받은 Subscription을 이용해서 Publisher에 데이터를 요청한다.
  • onNext(T t): Publisher가 next 신호를 보내면 호출된다.
  • onError(Throwable t): Publisher가 error 신호를 보내면 호출된다.
  • onComplete(): Publisher가 complete 신호를 보내면 호출된다.

각 메서드가 어떻게 동작하는지 다음 예제 코드로 알아보자.


Flux<Integer> seq = Flux.just(1, 2, 3);


seq.subscribe(new Subscriber<>() {

    private Subscription subscription;

    @Override

    public void onSubscribe(Subscription s) {

        System.out.println("Subscriber.onSubscribe");

        this.subscription = s;

        this.subscription.request(1); // Publisher에 데이터 요청

    }


    @Override

    public void onNext(Integer i) {

        System.out.println("Subscriber.onNext: " + i);

        this.subscription.request(1); // Publisher에 데이터 요청

    }


    @Override

    public void onError(Throwable t) {

        System.out.println("Subscriber.onError: " + t.getMessage());

    }


    @Override

    public void onComplete() {

        System.out.println("Subscriber.onComplete");

    }

});


subscribe() 메서드에 전달한 임의 Subscriber 객체의 onSubscribe() 메서드는 인자로 전달받은 Subscription 객체를 필드에 저장한다. Subscription은 구독 라이프사이클을 관리한다. 예를 들어 Subscription#request() 메서드는 Publisher에 데이터 요청 신호를 보낸다. 위 코드는 request(1)을 실행했는데 이는 1개의 데이터를 요청한다는 것을 의미한다. 즉 onSubscribe() 메서드는 파라미터로 전달받은 Subscription을 이용해서 Publisher에 1개의 데이터를 요청한다.

Publisher가 데이터 신호(next 신호)를 보내면 Subscriber#onNext() 메서드가 불린다. 위 예제에서는 전달받은 데이터를 출력하고 Subscription#request()를 이용해서 다음 데이터 1개를 요청한다. 즉 이 코드는 최초 구독 시점에 데이터 1개를 요청하고(onSubscribe) 이후 한 개의 데이터를 받으면 다시 한 개의 데이터를 요청한다(onNext).

실제 위 코드를 실행하면 다음 내용이 콘솔에 출력된다.

Subscriber.onSubscribe
Subscriber.onNext: 1
Subscriber.onNext: 2
Subscriber.onNext: 3
Subscriber.onComplete

이번엔 onNext() 메서드에서 다음처럼 subscription.request(1) 코드를 주석처리하고 다시 실행해보자.

Flux<Integer> seq = Flux.just(1, 2, 3);
seq.subscribe(new Subscriber<>() {
    ...생략

    @Override
    public void onNext(Integer i) {
        System.out.println("Subscriber.onNext: " + i);
        // this.subscription.request(1);
    }

    ...생략
});

결과는 다음과 같다.

Subscriber.onSubscribe
Subscriber.onNext: 1

onSubscribe()에서만 1개의 데이터를 요청하고 onNext()에서는 어떤 요청도 하지 않아 Publisher가 1개 데이터만 발생한 것을 알 수 있다.

request(Long.MAX_VALUE)를 사용하면 개수 제한없는 데이터 요청 신호를 Publisher에 보낸다. Publisher는 이 신호를 받으면 끝까지 데이터를 발생시킨다. 이를 다음과 같이 변경해보자.

Flux<Integer> seq = Flux.just(1, 2, 3);
seq.subscribe(new Subscriber<>() {
    private Subscription subscription;
    @Override
    public void onSubscribe(Subscription s) {
        System.out.println("Subscriber.onSubscribe");
        this.subscription = s;
        this.subscription.request(Long.MAX_VALUE);
    }

    @Override
    public void onNext(Integer i) {
        System.out.println("Subscriber.onNext: " + i);
    }

    ...생략
});

위 코드를 실행하면 Publisher가 모든 데이터를 발생한 것을 확인할 수 있다.

푸시 모델 vs 풀 모델

Subscription#request()는 Subscriber가 데이터를 처리할 수 있을 때 Publisher에게 데이터를 요청하는 풀(pull) 모델이다. 하지만 request(Long.MAX_VALUE)로 요청하면 Publisher는 개수 제한 없이 Subscriber에 데이터를 전송한다. 이는 완전한 푸시(push) 모델이다. 또 request(100000)을 사용하면 십 만 개의 데이터를 요청하고, Publisher는 발생한 데이터가 십 만 개가 될 때까지 신호를 보낸다. 데이터 요청은 풀 모델로 이루어졌지만 10만 개의 데이터를 전송하는 동안은 실질적으로 푸시 모델과 같다.

subscribe() 메서드

다음은 리액터가 제공하는 subscribe() 메서드이다.
  • subscribe()
  • subscribe(Consumer<? super T> consumer)
  • subscribe(Consumer<? super T> consumer,
                 Consumer<? super Throwable> errorConsumer)
  • subscribe(Consumer<? super T> consumer,
                 Consumer<? super Throwable> errorConsumer,
                 Runnable completeConsumer)
  • subscribe(Consumer<? super T> consumer,
                 Consumer<? super Throwable> errorConsumer,
                 Runnable completeConsumer,
                 Consumer<? super Subscription> subscriptionConsumer)
  • subscribe(Subscriber<? super T> actual)
  • subscribe(CoreSubscriber<? super T> actual)

메서드의 각 파라미터는 다음과 같다.

  • consumer: next 신호 처리
  • errorConsumer: error 신호 처리
  • completeConsumer: complete 신호 처리
  • subscriptionConsumer: Subscriber의 onSubscribe 메서드에 대응
  • actual: Subscriber나 CoreSubscriver 타입

관련글


Posted by 최범균 madvirus

댓글을 달아 주세요

Why Reactive? 책 요약(책은 여기에서 다운로드 가능)


1장. 소개


시스템은 다음과 같아야 함

  • 사용자에게 응답해야 함
  • 실패를 다루고 사용불능 상태에서도 동작해야 함
  • 다양한 부하 상황에서 견뎌야 함
  • 다양한 네트워크 상황에서 메시지를 보내고, 받고, 전달할 수 있어야 함
이를 위해 다음 필요
  • 하드웨어 자원 활용 제어 -> 응답성
  • 구성 요소를 분리 -> 독립적인 확장
  • 시스템 간 비동기 통신 ->  복원력, 탄력성(resilience)
리액티브 시스템의 이점이 여기에 있음. 

왜 지금인가?

다음 몇 가지 움직임이 리액티브 프로그래밍이 뜨는데 일조함
  • IoT와 모바일 : 서버가 동시에 수 백만의 연결된 장치를 처리해야 함 -> 병행과 분산 어플리케이션에 대한 요구가 급격히 증가
  • 클라우드, 컨테이너 : 경량의 가상화와 컨테이너 기술로 세밀한 범위로 더 빠르게 배포 가능 -> 더 편하게 할 수 있는 도구
과거부터 존재한 개념이 요즘 뜨는 이유
  1. 더 나은 자원 활용과 확정성에 대한 필요성 증가. 이를 위한 도구가 사용 가능해짐
  2. 모든 구현체가 상호운영할 수 있는 표준으로 특정 구현체에 얽매이는 위험 감소

2장. 어플리케이션 수준에서의 리액티브


리액티브와 비동기
  • 리액티브 프로그래밍에 있어 핵심 요소 중 하나는 태스크를 비동기로 실행할 수 있는 것
  • 리액티브 라이브러리, 구현의 공통 테마는 어떤 종류의 쓰레드 풀에 기반한 이벤트 루프나 공유 디스패처 인프라를 사용하는 것. 저렴한 구성 요소 간에 비싼 자원(thread)을 공유함으로써 단일 어플리케이션을 멀티 코어로 확장할 수 있음
  • 이런 멀티플렉싱 기술은 단일 장비로 백 만 엔티티를 다룰 수 있게 함
    • 쓰레드를 직접 사용하면, 사용자 당 액터를 만들 수 없고, 너무 무거워서 빨리 할 수 없고, 또한 쓰레드를 직접 다루는 게 간단하지 않으며, 프로그램이 다른 쓰레드 간 데이터 동기화 코드로 빠르게 지배당함
  • 비동기에서 주의할 점은 블로킹임. 파일, 네트워크 IO와 같은 블로킹 연산은 CPU 자원을 사용하지 않는데, 쓰레드가 블로킹되면서 다른 액터(또는 작업)을 실행하지 못하게 됨
    • 블로킹을 별도 쓰레드 풀로 분리해서 실행 -> 메인 이벤트 루프나 디스패처를 블록하면 안 됨
USL(Universal Scalability Law)
  • 통신 비용, 데이터 동기화 비용까지 고려
  • 적정 지점 이상으로 시스템 자원을 사용하게 밀어 붙이면, 더 이상 속도가 빨리지 않을 뿐 아니라, 전체 처리량에 부정적인 영향을 줌(백그라우드에서 일어나는 모든 종류의 조정 때문에 발생, 예 네트워크나 메모리 포화로 이런 조정 발생 가능)
  • 다양한 자원에 대한 경쟁이 발생할 수 있고, 과사용 문제는 CPU부터 네트워크까지 적용
역압(backpressure)
  • 최적 사용 상태 유지를 위한 역압 사용
    • 동기 API는 블록 연산으로 절로 역압이 된다
    • 비동기 API는 최대 성능을 낼 수 있는데, 이는 느린 하류 스트림이나 다른 어플리케이션을 압도할 수 있음
    • 리액티브 스트림 스펙은 스트림 라이브러리 사용자에게 투명하게 역압을 적용할 수 있도록 요구
    • 비동기 + 역압 -> 시스템의 한계까지 push할 수 있으나, 한계를 넘지는 않게 할 수 있음
  • 스트리밍 API와 제한된 메모리
    • 스트리밍의 두 면 : 소비 API, 생성 API
    • 스트리밍 API와 메모리에 제한된 처리 : 필요 이상 데이터를 메모리에 적재하지 않게 해 줌 -> 이는 용량 설계에 유용한 속성
    • 하류가 느릴 때 버퍼를 두어 하류에서 데이터를 처리할 수 있게 함
    • 무한정 버퍼에 담을 수 없으므로 제한된 크기의 버퍼 사용
    • 버퍼에 적재된 메시지의 비율로 지표 측정 가능(클라이언트가 얼마나 느린지, 서비스 레벨, 노드 활용 등)
    • 큐 버퍼를 모니터링해서 이벤트 발생 가능(예, 다 차면 클라이언트를 끊거나 오래된 메시지 삭제)

3장, 시스템 수준에서의 리액티브


분산 시스템과 메시징
  • 요청-응답 API의 문제 : 개발자가 할 수 있는 것을 제한
    • 예, HTTP는 이벤트 스트림을 받으려면 일부 hack이 필요, HTTP로 Job을 제출하고 제출 완료를 polling해야 함
  • 메시지 기반 시스템(akka 등)을 사용하면 어렵지 않게 할 수 있음
    • 예, Job 제출 세미지를 fire-and-forget으로 보내고 진행 상태를 메시지로 받으면 됨
    • 메시지를 받을 수 있는 addressable 엔티티만 있으면 됨
    • 요점: 매우 작음. 다른 시스템과 리액티브하게 상호작용하기 위한 비용 작음 (연결된 커넥션 X, 라운드 트림 X, 폴링 X)
    • HTTP로 메시징 같은 API를 설계 하려면 많은 고민(블로킹, 웹소켓, 폴링, SSE 선택) 필요하고 확장성도 떨어짐
부하에 살아남고 요금 아끼기
  • 최근 추세 : 컨테이너, 클러스터 오케스트레이션 -> 유연함(elastic)이 중요해짐
    • 스케일 up/out 만큼 scale down도 중요
    • 부하에 맞게 확장/축소해서 적정 비용 유지
    • 사전(proactively) 확정 : 언제 확장할지 결정할 수 있는 기술
    • 리액티브 서비스는 서비스 확장을 위한 성공 요인
탄력성(resilience)이 없으면 다른 것은 아무것도 아님
  • 리액티브의 여러 특징(성능, 확장성, 메시징 패턴 등) 중 가장 중요한 것은 탄력성
  • 시스템에 문제가 있을 때 완전히 불능 상태가 되면 제 아무리 빠르고 확장 가능한 시스템도 의미 없음
  • 공통의 비싼 자원에 접근하면, 그 자원이 단일 실패 지점이 될 수 있음
  • 리액티브 시스템은 "own your own data" 패턴을 따른다. 시스템이 주변에 대한 상태를 내부에 보관한다면 외부 정지 상황에서 살아남을 수 있음
4장, 리액티브 시스템의 빌딩 블록

  • 모든 것이 비동기인 경우는 흔치 않으므로, 점진적으로 리액티브 아키텍처로 넘어가기 위한 생산적인 방법 필요(예, Strangler Pattern: 점진적으로 블로킹/동기 앱을 비동기 앱으로 교체하는 패턴)
  • 리액티브로 넘어가기 전에 리액티브에 대해 고민하고 원칙을 이해하는 것이 중요 (단순히 기술만 추종하면 안 됨. 애자일에 대한 이해없이 애자일을 도입하고선 뭔가 잘 안 될 때 애자일을 탓하는 것과 동일한 상황이 발생할 수 있음)


Posted by 최범균 madvirus

댓글을 달아 주세요

"A Journey into Reactive Streams" 글 요약(원문은 여기 참고, 번역글은 여기 참고)


스트림

  • 스트림은 시간이 지남에 따라 생성되는 일련의 요소들
  • 시작과 끝이 없을 수 있음
스트림과 배열의 차이
  • 스트림 처리 시스템에서 모든 스트림 요소를 접근할 수는 없음
  • 요소가 다른 속도로 발생할 뿐만 아니라 모든 요소를 처리할 거라 보장할 수 없음
  • 스트림이 아직 존재하지 않을 수도 있고, 끝 개념이 없음

리액티브 스트림


리액티브 스트림 목표

  • 비즈니스 개발자가 스트림 처리를 위한 저수준 작업에 신경쓰지 않도록 추상화 수준을 높이는 것
스트림 처리 영역의 도전 과제를 해결하기 위해
  1. 무한 버퍼 없이, 소비 비율에 따라 리액티브(push)와 인터랙티브(pull) 모델을 자동 전환
  2. 라이브러리, 시스템, 네트워크, 프로세스 간 상호운영
비동기성
  • 컴퓨팅 자원을 병렬 사용하기 위해 필요 (동기 블로킹 호출 -> 자원 활용의 악!)
  • 비동기 경계 개념이 스펙 핵심에 위치
    • 비동기 경계 -> 시스템 컴포넌트 결합 제거, 시간에 대한 결합 제거
역압(back pressure)
  • 스트림 발생과 구독자 간의 발생/처리 속도 차 발생
    • 스트림 참영자가 흐름 제어에 참여해서 꾸준하게 운영 상태를 유지하고 매끄럽게 저하시킬 수 있게 함으로써 탄력성을 제공한다.
  • 데이터 양방향 흐름 제어
    • 구독자가 퍼블리셔에 demand 신호
    • 퍼블리셔는 안전하게 요청한 개수의 요소 제공
    • demand는 비동기로 요청 -> 자원 낭비 제거
    • demand는 그 다음 상류까지 전파: 전체 흐름에서 역압은 과부하에서 응답할 수 있는 기회를 줌
  • 리액티브 시스템은 사실상 push 기반
    • 구독이 느리고 퍼블리셔가 빠르면 pull처럼 동작
    • demand(1) = pull
  • 주요 가치 : 모든 호환 라이브러리 간 탄력성


Posted by 최범균 madvirus

댓글을 달아 주세요

What is Reactive Programming? 글 요약 (원문은 여기 참고)


원문 제목은 리액티브 프로그래밍이나 실제 내용은 리액티브 시스템에 대한 내용을 담고 있음.


개발자가 직면한 것

  • 1) H/W 발전, 2) 인터넷(엄청난 트래픽!)
  • SW의 중요성, 기대 수준, 규모

문제 상황(grey sky)을 대비하지 않으면, 매우 높은 대가를 치를 수 있다.


리액티브 시스템으로 이런 문제를 해결


리액티브 시스템 4가지 원칙


[출처: https://www.reactivemanifesto.org/]

  • 응답성(Responsive) : 사용자에게 일관된 긍정적인 경험을 제공하기 위해 상황에 상관없이 모든 사용자에게 빠르게 응답
  • 유연성(Elastic) : 다양한 부하 상황에서 응답
  • 탄력성(Resilient) : 실패 상황에서 응답
  • 메시지 구동(Message Driven) : 시간, 공간에 대한 커플링 제거(비동기 경계)

탄력성

  • 오늘날 어플리케이션은 다양한 상황에서 응답성을 유지하기 위해 회복 탄력성을 가져야 한다.
  • 성능, 내구성, 보안 등 모든 측면이 탄력성 필요
메시지 구동에 기반한 탄력성

메시지 구동 아키텍처로 얻을 수 있는 것: 견고한 에러 처리와 내고장성
  • 격리 : 시스템이 자가 회복하기 위해 필요. 격리된 컴포넌트의 실패는 전체 시스템의 응답성에 영향을 주지 않음. 실패한 컴포넌트 또한 회복할 기회를 가짐
  • 위치 투명성 : 같은 VM의 프로세스처럼 다른 노드의 다른 프로세스와 상호작용할 수 있다.
  • 전용 에러 채널 : 호출한 곳에 에러를 던지는 것 외에 다른 어딘가로 에러 신호를 리다이렉트하는 것을 허용
유연성 또는 확장성
  • 다양항 부하 상황에서 응답할 수 있도록 시스템을 쉽게 확대/축소할 수 있어야 함
  • 패러다임 먼저
    • 병행 처리에서 쓰레드 기반은 한계를 가짐
      • 공유 가변 상태, 요청 당 쓰레드, 변이 상태 동시 접근 : 성능, 확장 임계점에 빠르게 도달
      • 쓰레드 안정성을 위한 복잡함,어려움 증가

메시지 구동 2가지 : 이벤트 방식과 액터 기반


이벤트 방식

  • 0개 이상 옵저버가 모니터링하는 이벤트에 기반
  • 호출자가 옵저버 응답을 기다리지 않음
  • 이벤트는 특정 수신자(줏소)를 직접 지정하지 않음
액터 기반
  • 메시지 전달 아키텍처 확장
  • 메시지를 전달할 수취인 지정
  • 메시지를 쓰레드 경계 간에 또는 다른 서버 액터에 전달 가능

액터 장점

  • 네트워크 경계를 넘어 연산 확장 쉬움
  • 액터에 메시지를 직접 보내서 콜백지옥 없어짐(액터 간 메시지 흐름만 생각하면 됨)
  • 컴포넌트 간 결합도 낮춤


Posted by 최범균 madvirus

댓글을 달아 주세요

리액티브 관련 자주 나오는 용어 정리


동기, 비동기


 용어

동기(synchronous)

비동기(asynchronous)

 설명

한 프로세스(쓰레드)가 작업을 순차 실행

다른 프로세스(쓰레드)로 작업을 실행

 비고

작업 완료 여부를 호출하는 곳에서 처리

작업 완료 여부를 호출된 곳에서 처리 

동시에 실행할 수도 있고 지금이 아닌 미래 시점에 실행할 수도 있음


블록, 논블록


 용어

블록(block)

논블록(non-block)

 설명

작업 실행이 끝날 때가지 쓰레드가 다른 작업을 하지 못하고 대기

작업 완료를 기다리지 않고 진행

 비고

호출된 곳에서 작업 완료 후 리턴

호출된 곳에서 바로 리턴


병행, 병렬


 용어

병행(concurrency)

병렬(parallelism)

설명

주어진 시점에 두 개 이상의 작업 진행

주어진 시점에 두 개 이상의 작업이 동시 발생

  • 병렬 처리를 위한 서로 다른 처리 장치(CPU) 필요 (병행처리는 필수 아님)
  • 병렬은 병행을 내포

비고

모듈화, 응답성, 유지보수성 중요

(프로그램 속성)


주요 관심

  • 언제 실행 시작
  • 정보 교환 방식
  • 공유 자원 관리

효율이 주요 관심

(머신 속성)


주요 관심

더 빨리 계산하기 위해

- 큰 문제를 작은 문제로 나누는 방법 고민

- 병렬 HW 사용 최적화

 




Posted by 최범균 madvirus

댓글을 달아 주세요

"5 Things to Know About Reactive Programming" 글 요약(원문은 여기 참고)


1. 리액티브 프로그래밍은 비동기 데이터 스트림을 이용한 프로그래밍

  • 리액티브 프로그래밍 사용시, 데이터 스트림이 어플리케이션의 뼈대가 됨
  • 이벤트, 메시지, 호출, 실패를 데이터 스트림으로 전달
  • 이 스트림을 Observe(Subscrive)하고, 값을 발생(emit)할 때 반응
  • 모든 것이 스트림: 클릭 이벤트, HTTP 요청, 유입 메시지, 변수 변경, 세선 값 등 바뀌거나 발생할 수 있는 모든 것 (이는 본질적으로 비동기와 관련)
2. 콜드(Cold) vs 핫(Hot)
  • 콜드 스트림 : 누군가 Observe를 시작할 때까지 아무것도 안 함. 스트림이 소비될 때 동작하기 시작. 여러 subscriber가 공유하지 않음. 예) 파일 다운로드
  • 핫 스트림 : 소비 전에 활성. 개별 subscriber에 독립적으로 데이터 생성. 구독하기 시작한 이후의 데이터 수신. 예) 실시간 주식 주가, 센서 데이터
3. 비동기 오용 주의
  • 비동기는 리액티브 프로그래밍에서 중요한 단어
  • 중요한 세 가지 : 부수 효과, 쓰레드, 블록
    • 부수 효과 : 불필요한 부수 효과를 피할 것. 부수 효과 없는 함수 -> 쓰레드 안정성
    • 쓰레드 : 너무 많은 쓰레드 사용을 피할 것. 다중 쓰레드는 동기화 문제 위험
    • 블록 : 쓰레드를 소유하지 않으므로 쓰레드를 절대 블록하지 말 것
4. 단순
  • 다른 개발자가 읽을 코드임을 잊지 말 것
5. 리액티브 프로그래밍 != 리액티브 시스템


Posted by 최범균 madvirus

댓글을 달아 주세요