😀
fistkim TECH BLOG
  • Intro
  • 강의
    • Reactive Programming in Modern Java using Project Reactor
      • Reactor execution model 1
      • Reactor execution model 2
      • Reactor execution model 3 - parallelism
      • Reactor execution model 4 - overview
      • Transform
      • Combine
      • Side Effect Methods
      • Exception/Error handling
      • retry, retryWhen, repeat
      • BackPressure
      • Cold & Hot Streams
    • NEXTSTEP 클린코드 with java 9기
      • 정리노트
    • NEXTSTEP DDD 세레나데 2기
      • CH01 도메인 주도 설계 이해
      • CH02 크게 소리 내어 모델링 하기
      • CH03 도메인 주도 설계 기본 요소
      • CH04 도메인 주도 설계 아키텍처
      • CH05 도메인 이벤트
    • NEXTSTEP 인프라 공방 1기
      • 망 분리하기
      • 통신 확인하기
      • 도커 컨테이너 이해하기
      • [미션 1] 서비스 구성하기 실습
      • [미션 2] 서비스 배포하기 실습
      • 서버 진단하기
      • 어플리케이션 진단하기
      • [미션 3] 서비스 운영하기
      • 웹 성능 진단하기
      • 부하 테스트
      • k6
      • [미션 4] 성능 테스트
      • 리버스 프록시 개선하기
      • 캐싱 활용하기
      • [미션 5] 화면 응답 개선하기
      • Redis Annotation 및 설정
      • 인덱스 이해하기 & DB 튜닝
      • [미션 6-1] 조회 성능 개선하기
      • [미션 6-2] DB 이중화 적용
    • NEXTSTEP 만들면서 배우는 Spring 3기
      • CH01 올바른 방향 바라보기
      • CH02 HTTP 이해 - 웹 서버 구현
        • HTTP 파싱
        • HTTP 웹 서버 구현
      • CH03 MVC - @MVC 프레임워크 구현
        • Servlet 다시 짚기
        • Cookie, Session 다시 짚기
        • MVC 프레임워크 구현
      • CH04 나만의 라이브러리 구현
      • CH05 DI - DI 프레임워크 구현
      • CH06 Aspect OP
    • 스프링 시큐리티
      • 스프링 시큐리티 아키텍처
      • WebAsyncManagerIntegrationFilter
      • SecurityContextPersistenceFilter
      • HeaderWriterFilter
      • CsrfFilter
      • (+) 스프링 시큐리티 + JWT
      • (+) 마치며
    • 더 자바, 코드를 조작하는 다양한 방법
      • CH01 JVM 이해하기
      • (+) 클래스 로더 이해하기
      • CH02 바이트 코드 분석 및 조작
      • (+) jacoco
      • CH03 리플렉션
      • CH04 다이나믹 프록시
      • CH05 애노테이션 프로세서
    • 더 자바, 애플리케이션을 테스트하는 다양한 방법
      • CH01 JUnit 5
      • CH02 Mockito
      • (+) Spy vs Mock
      • CH03 도커와 테스트
      • CH04 성능 테스트
      • (+) VisualVM
      • (+) 테스트 자동화
      • CH05 운영 이슈 테스트
      • CH06 아키텍처 테스트
    • 모든 개발자를 위한 HTTP 웹 기본 지식
      • CH01 인터넷 네트워크
      • CH02 HTTP 기본
      • CH03 HTTP 메서드 속성
      • CH04 HTTP 메서드 활용
      • CH05 HTTP 상태코드
      • CH06 HTTP 헤더1 - 일반 헤더
      • CH07 HTTP 헤더2 - 캐시와 조건부 요청
      • (+) HTTPS 원리
    • 스프링 프레임워크 핵심 기술
      • CH01 IOC 컨테이너
      • CH02 AOP
      • (+) 스프링 의존성 관리
      • (+) 생성자 주입 장점
    • 코딩으로 학습하는 GoF의 디자인 패턴
      • 객체 생성
        • 싱글톤 패턴
        • 팩토리 메소드 패턴
        • 추상 팩토리 패턴
        • 빌더 패턴
        • 프로토타입 패턴
      • 구조
        • 어댑터 패턴
        • 브릿지 패턴
        • 컴포짓 패턴
      • 행동
        • (작성중)
    • 실전 Querydsl
      • CH01 프로젝트 환경구성
      • CH02 예제 도메인 모델
      • CH03 기본문법
      • CH04 중급 문법
      • CH05 실무활용 (스프링 데이터 JPA와 Querydsl)
      • CH06 스프링데이터JPA 가 제공하는 Querydsl 기능
      • (+) 별칭(alias)
      • (+) Slice 쿼리
    • 스프링 데이터 JPA
      • CH01 핵심개념이해 1
      • CH02 핵심개념이해 2
      • CH03 핵심개념이해 3
      • CH04 Spring Data Common
      • CH05 Spring Data JPA
    • 실전! 스프링 부트와 JPA 활용2 - API 개발과 성능 최적화
      • CH01 지연 로딩과 조회 성능 최적화
      • CH02 컬렉션 조회 최적화
      • CH03 전체 정리
    • 초보를 위한 쿠버네티스 안내서
      • CH01 쿠버네티스 시작하기
      • CH02 쿠버네티스 알아보기
      • CH03 쿠버네티스 실습 준비
      • CH04 쿠버네티스 기본 실습
    • Flutter Provider Essential
      • CH01 Introduction
      • CH02 Provider Overview
      • CH03 TODO App
      • CH04 Weather App
      • CH05 Firebase Authentication App
    • Flutter Bloc Essential
      • CH01 Introduction
      • CH02 Bloc Overview
      • CH03 TODO App
      • CH04 Weather App
      • CH05 Firebase Authentication App
    • Flutter Advanced Course - Clean Architecture With MVVM
      • CH01 Introduction
      • CH02 Clean Architecture 4 Layer
      • CH03 MVVM
      • CH04 Data Layer
      • (+) Data Layer - response to model
      • (+) Data Layer - Network
      • CH05 Domain Layer
      • CH06 Presentation Layer
      • CH07 Application Layer
      • (+) Application Layer - l10n
      • (+) Application Layer - DI
      • (+) Application Layer - environment
    • 자바 알고리즘 입문
      • CH01 문자열
      • CH02 Array(1, 2 차원 배열)
      • CH03 Two pointers, Sliding window[효율성: O(n^2)-->O(n)]
      • CH04 HashMap, TreeSet (해쉬, 정렬지원 Set)
      • CH05 Stack, Queue(자료구조)
      • CH06 Sorting and Searching(정렬, 이분검색과 결정알고리즘)
      • CH07 Recursive, Tree, Graph(DFS, BFS 기초)
      • CH08 DFS, BFS 활용
      • CH09 Greedy Algorithm
      • CH10 dynamic programming(동적계획법)
  • 도서
    • 만들면서 배우는 클린 아키텍처
      • 학습목표
      • CH01 계층형 아키텍처의 문제는 무엇일까?
      • CH02 의존성 역전하기
      • CH03 코드 구성하기
      • CH04 유스케이스 구현하기
      • CH05 웹 어댑터 구현하기
      • CH06 영속성 어댑터 구현하기
      • CH07 아키텍처 요소 테스트하기
      • CH08 경계 간 매핑하기
      • CH09 어플리케이션 조립하기
      • CH10 아키텍처 경계 강제하기
      • CH11 의식적으로 지름길 사용하기
      • CH12 아키텍처 스타일 결정하기
    • 클린 아키텍처
      • 들어가며
      • 1부 소개
        • 1장 설계와 아키텍처란?
        • 2장 두 가지 가치에 대한 이야기
      • 2부 벽돌부터 시작하기: 프로그래밍 패러다임
        • 3장 패러다임 개요
        • 4장 구조적 프로그래밍
        • 5장 객체 지향 프로그래밍
        • 6장 함수형 프로그래밍
      • 3부 설계 원칙
        • 7장 SRP: 단일 책임 원칙
        • 8장 OCP: 개방-폐쇄 원칙
        • 9장 LSP: 리스코프 치환 원칙
        • 10장 ISP: 인터페이스 분리 원칙
        • 11장 DIP: 의존성 역전 원칙
      • 4부 컴포넌트 원칙
        • 12장 컴포넌트
        • 13장 컴포넌트 응집도
        • 14장 컴포넌트 결합
      • 5부
        • 15장 아키텍처란?
    • 스프링 입문을 위한 자바 객체 지향의 원리와 이해
      • CH01 사람을 사랑한 기술
      • CH02 자바와 절차적/구조적 프로그래밍
      • CH03 자바와 객체 지향
      • (+) 자바 코드 실행에 따른 메모리 적재과정
      • CH04 자바가 확장한 객체 지향
      • CH05 객체 지향 설계 5 원칙 - SOLID
      • CH06 스프링이 사랑한 디자인 패턴
      • CH07 스프링 삼각형과 설정 정보
      • (부록) 람다(lambda)
    • 객체지향의 사실과 오해
      • CH01 협력하는 객체들의 공동체
      • CH02 이상한 나라의 객체
      • CH03 타입과 추상화
      • CH04 역할, 책임, 협력
      • CH05 책임과 메시지
      • CH06 객체 지도
      • CH07 함께 모으기
      • (+) 인터페이스 개념 바로잡기
    • 도메인 주도 개발 시작하기
      • CH01 도메인 모델 시작하기
      • CH02 아키텍처 개요
      • CH03 애그리거트
      • CH04 리포지터리와 모델 구현
      • CH05 스프링 데이터 JPA를 이용한 조회 기능
      • CH06 응용 서비스와 표현 영역
      • CH07 도메인 서비스
      • CH08 애그리거트 트랜잭션 관리
      • CH09 도메인 모델과 바운디드 컨텍스트
      • CH10 이벤트
      • CH11 CQRS
    • 자바 ORM 표준 JPA 프로그래밍
      • CH01 JPA 소개
      • CH02 JPA 시작
      • CH03 영속성 관리
      • CH04 엔티티 매핑
      • CH05 연관관계 매핑 기초
      • CH06 다양한 연관관계 매핑
      • CH07 고급 매핑
      • CH08 프록시와 연관관계 관리
      • CH09 값 타입
      • CH10 객체지향 쿼리 언어
      • CH11 웹 애플리케이션 제작
      • CH12 스프링 데이터 JPA
      • CH13 웹 애플리케이션과 영속성 관리
      • CH14 컬렉션과 부가 기능
      • CH15 고급 주제와 성능 최적화
      • CH16 트랜잭션과 락, 2차 캐시
    • 소프트웨어 세상을 여는 컴퓨터과학
      • CH01 컴퓨터 과학 소개
      • CH02 데이터 표현과 디지털 논리
    • 이펙티브 자바
      • 1 장 들어가기
      • 2장 객체 생성과 파괴
        • [01] 생성자 대신 정적 팩터리 메서드를 고려하라
        • [02] 생성자에 매개변수가 많다면 빌더를 고려하라
        • [03] private 생성자나 열거 타입으로 싱글턴임을 보증하라
        • [04] 인스턴스화를 막으려거든 private 생성자를 사용하라
        • [05] 자원을 직접 명시하지 말고 의존 객체 주입을 사용하라
        • [06] 불필요한 객체 생성을 피하라
        • [07] 다 쓴 객체 참조를 해제하라
        • [08] finalizer 와 cleaner 사용을 피하라
        • [09] try-finally 보다는 try-with-resources 를 사용하라
      • 3장 모든 객체의 공통 메서드
        • [10] equals는 일반 규약을 지켜 재정의하라
        • [11] equals 를 재정의하려거든 hashCode도 재정의하라
        • [12] toString 을 항상 재정의하라
        • [13] clone 재정의는 주의해서 진행하라
        • [14] Comparable 을 구현할지 고려하라
      • 4장 클래스와 인터페이스
        • [15] 클래스와 멤버의 접근 권한을 최소화하라
  • 토픽
    • 서버 모니터링
      • CPU 사용량
      • 메모리 사용량
      • 스레드 풀
    • Spring Boot Monitoring
      • Spring actuator
      • Spring eureka
      • Prometheus
      • grafana
      • Spring actuator + Prometheus + grafana
    • JAVA 데일리 토픽
      • 메모리 누수(memory leak)
      • 객체 참조의 유형
      • 커스텀 스레드 풀
      • Mark And Compact
      • serialVersionUID 이해하기
      • 함수형 인터페이스
      • 메소드 참조
      • equals()와 hashCode()가 무엇이고 역할이 무엇인지
      • StringBuffer vs StringBuilder
      • String vs StringBuilder, StringBuffer
      • String interning
    • JAVA GC
    • 프로그래머스 문제 풀기
      • 해시
      • 스택/큐
      • 힙(Heap)
      • 정렬
      • 완전탐색
      • DFS/BFS
    • 데이터베이스 구성 및 작동 흐름
    • 데이터베이스 JOIN 원리
    • 객체지향생활체조 원칙
    • 상태(state), 상속(inheritance), 합성(composition) 의 상관관계
    • java enum은 메모리에 언제, 어떻게 할당되는가
    • Checked Exception vs UnChecked Exception
    • Reactive Streams 원리탐구 - 간단한 예제 직접 작성해보기
    • Flutter Basic
    • Flutter StatefulWidget 생명주기
    • Flutter 가 위젯을 그리는 원리
    • Flutter 클린 아키텍처
      • application layer
        • 패키지 구조 및 레이어 설명
        • environment
        • dependency injection
        • go_router
        • foreground & background
        • 다국어처리 (l10n, i18n)
        • Global 처리(시스템 점검, fore->back 등)
        • connection_manager
        • permission_manager
        • push_notification_manager
        • firebase 연동
      • data layer
        • 패키지 구조 및 레이어 설명
        • network
        • repository
      • domain layer
        • 패키지 구조 및 레이어 설명
      • presentation layer
        • 패키지 구조 및 레이어 설명
        • resources
    • 기술 관련 포스팅 읽기
  • 기타
    • 작업일지
      • 2023. 10
      • 2023. 09
      • 2023. 08
      • 2023. 07
      • 2023. 06
      • 2023. 05
      • 2023. 04
      • 2023. 03
      • 2023. 02
      • 2023. 01
      • 2022. 12
    • Business Model
      • 아이디어 불패의 법칙
      • 린 모바일 앱 개발
      • 린 스타트업
      • 제로투원
      • MIT 스타트업 바이블
      • 린치핀
    • 백로그 종합
Powered by GitBook
On this page
  • 들어가며
  • 웹플럭스는 정말 빠른가. 빠르다면 왜 빠른걸까
  • Spring MVC의 처리방식
  • Spring WebFlux의 처리방식
  • 비유를 통해 정리해보는 Spring WebFlux vs Spring MVC
  • 비동기, 논블로킹에 대해서 다시 짚어보기
  • 동기 vs 비동기
  • 블로킹 vs 논블로킹
  1. 강의
  2. Reactive Programming in Modern Java using Project Reactor

Reactor execution model 1

리액터의 동작 모델&원리에 관한 탐구

PreviousReactive Programming in Modern Java using Project ReactorNextReactor execution model 2

Last updated 1 year ago

들어가며

다른 공식 문서나 강의 같은 것들을 보아도 execution model 보다 operator 들을 먼저 소개 및 학습한다. 나도 그렇게 공부를 했지만 점점 execution model 자체에 대한 깊은 이해가 없이는 단지 얄팍한 기술만 알게 되는 느낌이고 공부하면 할 수록 원리에 대한 이해의 필요성이 커지는 것 같다. 그래서 학습을 하다가 뒤에 나온 execution model에 대한 내용을 맨 앞으로 옮겨서 정리하게 되었다.

최근에 회사 프로젝트에서 flatMapSequential()을 사용할 일이 있었다. 더 정확히 표현하자면 flatMapSequential()을 쓰지 않아도 되는 부분이었는데 내가 생각하기엔 속도를 위해서 쓰면 좋겠다고 생각해서 썼던 적이 있다. 그 때 팀원분께서 오버헤드가 발생하니 map으로 쓰는게 좋겠다고 피드백을 주셨는데, 그 부분에 대해서 이야기를 나누다가 보니 내가 지금까지 flatMap 자체에 대해서 이해도가 부족했다는 것을 알게 되었다. 덕분에 완전히 오해하고 있었던 개념을 인지할 수 있었다.

팀원분의 피드백 덕분에 내가 마주한 나의 리액터에 대한 오해와 이번 executioni model은 매우 밀접하게 맞닿아 있다. 결국 정리하자면 나는 리액터의 execution model 에 대해서 이해가 부족한 사람이었던 것이다.

이에 관해 공부를 해보니 어떤 operator 들이 있고, 각 operator 들은 어떤 기능을 하는지에 대한 이해보다 훨씬 더 중요하다는 생각이 들어서 페이지상 순서를 앞으로 배치하게 되었다.

웹플럭스는 정말 빠른가. 빠르다면 왜 빠른걸까

지금 내가 듣는 udemy 강의에서도 이 주제에 대해서 초반에 다루긴 했지만 이 강의가 나에겐 더 도움이 많이 되었다. 결론적으로 요약하자면 Spring WebFlux 가 Spring MVC 에 비해서 더 높은 처리량과 빠른 응답속도를 보여줬다. 하지만 조금 더 디테일하게 들여다 보면 이렇게 단편적으로만 말할 수는 없다는 것을 알 수 있다.

다시 말해, 단순하게 'WebFlux가 MVC보다 무조건 빠릅니다' 라는 말을 하는 것은 틀린 말이라는 것이다. 위 영상에서 그래프와 숫자로 비교해주고 있지만 상황에 따라, 또 작성된 코드에 따라 속도차이는 발생하며 가장 이상적으로 처리를 잘 한 상태에서 트래픽이 일정량 이상일때만 WebFlux가 MVC보다 평균적으로 더 빠른 응답속도를 보여준다고 말할 수 있다.

또 한 가지를 덧붙이자면 그렇다고 WebFlux가 무조건 더 좋은 것도 아닌것이 코드 가독성도 떨어지고 디버깅도 MVC 에 비해서 상대적으로 더 어렵다.

아래에 나오는 모든 이미지의 출처는 위 유투브 영상이다.

Spring MVC의 처리방식

Spring MVC는 request per thread 가 원칙이다. 즉, 각 요청에 대해서 스레드풀 내에 있는 하나의 스레드가 이를 전적으로 책임지고 끝까지 로직을 처리하여 응답을 주는 것이다. 위 그림은 이에 대한 설명이다. 브라우저의 요청에 대해서 스레드풀의 6번째 스레드가 이를 받아 처리하는 모습이다. (일반적으로 톰캣의 기본 스레드 설정은 200개 이다.)

위 그림은 첫번째 그림의 Spring MVC Application 내부에서 스레드가 일하는 모습이다. 양쪽으로 검정색 선의 네모가 보이는데 둘은 서버이다. 즉, 좌측의 서버가 우측의 서버에 REST API를 호출하여 응답을 받아 처리하는 모습이다.

그림의 예시는 1번 스레드가 이를 처리하는 중에 어떠한 외부 서버(우측 네모)로 REST API를 요청한 뒤, 응답이 올 때까지 block 상태에 있다가 외부 서버에서 응답이 오자마자 다시 Task3이 실행되는 모습이다.

reactor의 execution model을 이해하기 위해 이 부분에서 유의하여 봐야할 부분은 아래와 같다.

  • 1번 스레드가 외부 서버로 REAT API를 호출한 뒤 block 상태로 '일하지 않고 그냥 대기' 하고 있다는 것이다. 스레드가 block 되어 I/O가 끝날 때 까지 waiting 한다는 것이다. (외부의 응답이 늦는 것은 어쩔 수가 없기에 응답이 올때까지는 마냥 기다릴 것이 아니라 할 수 있는 일을 하면 되는데 그렇게 하지 않고 기다리는 것이 문제인 것이다. 즉, 하드웨어 성능을 더 쥐어짤 수 있는데 자원을 할당받고 로직을 처리하는 실행 단위인 스레드가 다 소진될 여지가 커지니까 이게 문제인 것이다)

  • thread의 상태가 runnable, waiting, runnable로 자주 바뀐다는 것이 곧 context switching의 발생을 의미한다.

  • 톰캣 기본값 기준 200개의 스레드가 CPU를 할당 받기 위해 경합하면서 오버헤드가 발생한다.(아무래도 CPU의 스케줄링 방식이 무엇이든 받고자하는 주체의 수가 많을 수록 스케줄링 계산을 모두 해줘야하니까 자원을 할당해줄 후보가 많을 수록 확실히 오버헤드가 많을 수 밖에 없는 것 같음)

Spring WebFlux의 처리방식

Spring WebFlux는 Event Loop 방식으로 동작한다. 즉, 사용자들의 요청 및 어플리케이션 내에서 처리해야할 과정들은 모두 event 라는 단위로 event queue에 적재되어 처리된다. Event Loop는 이렇게 적재된 event를 순차적으로 꺼내서 처리하게 된다.

Spring WebFlux는 reactor 와 netty를 기반으로 동작하는데 위 장표에도 나와있다시피 netty의 스레드 풀의 스레드 개수는 코어 * 2 이다.

여기서 위 MVC 방식과 비교하면 두 가지 차이를 인지할 수 있다.

  • 스레드의 수 자체가 적어서 CPU 경합시 발생하는 오버헤드가 상대적으로 적다.

  • 스레드가 블로킹되지 않아서 context switching 으로 인한 오버헤드 비용이 줄어든다.

결국 위 그림과 같이 스레드들이 블로킹 되지 않는 시간적 구간에 다른 일을 처리할 수 있어서 성능을 쥐어 짤 수 있다. 위 MVC 때와 비교하자면 1번 스레드가 Task 1 을 수행하고 블로킹이 된 상태로 무의미하게 대기를 했었는데 WebFlux의 경우에는 그 시간에 다른 일을 처리할 수 있는 것이다.

결국 WebFlux가 MVC에 비해서 일을 할 수 있는 Free한 스레드가 더 많을 가능성이 다고 말할 수 있다. 단순히 스레드 풀의 개수자체는 MVC가 200개이고 WebFlux가 그보다 훨씬 적지만 WebFlux는 위 그림과 같이 논블로킹 방식으로 동작하므로 트래픽이 많아질 수록 이벤트 루프의 메인 스레드가 '이거 처리할 사람?' 하고 물어봤을때 '저요'라고 손들 수 있는 스레드가 많을 가능성이 크다는 것을 의미한다.

반대로 MVC에서는 이때 외부 서버의 응답을 기다리거나, DB로부터 응답을 기다리는 등의 이유로 블로킹에 걸린 스레드들이 많으면 당장 그 순간에는 일을 안하고 있는데 일을 하고 있긴한 상태의 스레드가 많을 수 있고, 결론적으로 요청이 들어온 그 순간에는 정작 일을 처리할 스레드가 없어서 요청이 대기할 가능성이 크다고 할 수 있다.

비유를 통해 정리해보는 Spring WebFlux vs Spring MVC

CPU 코어가 4개라는 가정에서 MVC와 WebFlux를 극단적인 비유를 통해 비교해보자.

상황은 사무실에 직원이 MVC(200명), WebFlux(8명) 이 일하고 있고 프린터가 4대가 있다고 하자. 직원들은 문서를 출력하거나 전화를 받거나 문서를 작성하는 등의 업무를 수행한다.

Spring MVC

  1. 현재 200명은 놀고 있는 상태다.

  2. 문서를 출력하는 업무가 200건이 동시에 들어왔다.

  3. 200명 모두에게 1건씩 할당된다.

  4. 200명이 모두 동시에 프린터 출력을 시도했다.

  5. 아직 한장의 프린트도 완료되기 전에 갑자기 전화 업무가 50건이 들어왔다.

  6. 프린터 출력을 기다리는 직원들은 전화를 받을 수 있지만 받지 않는다. 프린트기가 출력해줄 프린트물을 기다리고 있기 때문이다.

  7. 전화를 건 사람은 누가 받기를 기다리며 계속 대기한다.

  8. 먼저 출력시도 한 순서로 프린트 물이 출력된다. 프린트 물을 받아든 사람은 그제서야 전화를 받기 시작한다.

  9. 순차적으로 프린트가 완료된 직원들이 차례차례 대기중인 전화를 받는다.

WebFlux

  1. 현재 8명은 놀고 있는 상태다.

  2. 문서를 출력하는 업무가 200건이 동시에 들어왔다.

  3. 1명이 1건의 문서출력업무를 할당받고 프린트 출력 버튼을 누른다. 그리고 그 프린트물이 아직 프린트되어 나오기 전이지만 작업을 끝낸 작업자는 곧 바로 또 다른 문서출력 업무 1건을 가져가서 출력 버튼을 누른다. 이런 방식으로 200건이 모두 프린터기에 출력 명령이 들어갈때 까지 8명 모두가 이를 순차적으로 1건씩 받아 처리한다.

  4. 갑자기 전화 업무가 50건이 들어왔다.

  5. 200건의 문서에 대해서 프린트 출력 버튼이 모두 눌러진 상태라면 아직 프린트물이 나오지 않았어도 가장 먼저 여유가 있어서 작업을 할당 받을 수 있는 작업자가 전화를 받는다.

비동기, 논블로킹에 대해서 다시 짚어보기

동기 vs 비동기

하지만 위 글에서 '동기'에 관해 예시를 들어둔 것중 instant messaging은 개인적으로 '동기'에 넣으면 안된다고 본다. 그 외에 비유는 매우 적절한 것 같아서 링크를 달아둔다.

비유들만 옮기자면 화상채팅, 직접 대면, 전화통화가 '동기'적 cummunication 방식이고 '비동기'적 communication 방식으로는 이메일, Video recording(이걸 누가 요즘..?), Cloud collaboration(매우 좋은 예시인 것 같다), Project management software(이것도 매우 좋은 예시라고 생각한다)와 같은 것들이 있다.

여기서 확실히 짚어야 할 부분은 '비동기'와 '논블로킹'은 다른 개념이라는 것이다. 극단적인 예시로 요청자가 '비동기'통신을 하지만 통신 직후에 아무것도 못하게 하면 '블로킹'이 되는 것이긴 하다는 것을 생각해보면 다른 개념임을 확실히 할 수 있다.

응답이 얼마나 걸리든 요청자 입장에서 응답을 요청한 시점부터 바로 이어서 받느냐, 응답의 시점이 뚝 끊겨서 나중에 받느냐에 따라서 '동기'와 '비동기'가 갈린다.

극단적으로 응답을 하기 위해서 1시간이 걸리는 작업이 있다고 한다면 요청자가 요청 직후에 '그래 준비되면 알려줘' 라고 하고 '나중에 알아서 준비되면 연락이 온다'는 것을 인지하고 있다면 '비동기'라고 볼 수 있고(=callBack), 1시간 내내 응답을 받기까지 대기한다면 결국 요청과 응답이 동기적으로 이뤄진다고 봐야하기 때문에 '동기' 방식으로 봐야한다.

시간이 얼마나 걸리는지가 중요한 것이 아니라 의사소통의 형태가 '동기'와 '비동기'를 가른다.

블로킹 vs 논블로킹

IBM의 글에서 '비동기', '논블로킹' 모델 하나만 가져오자면 아래와 같다.

블로킹과 논블로킹을 가르는 핵심은 요청자 측에서 요청 직후 '다른 일을 할 수 있는가'의 기준이다. 스레드 입장에서 보면 요청 직후 결과가 어찌되었건 상태가 waiting이 되는 것이 아니라 runnable을 그대로 유지할 수 있어야만 '논블로킹'하다고 할 수 있다.

위 그림은 Spring WebFlux가 동작하는 모습을 보여준다. Task1, Task3 모두 Event로 만들어져서 이벤트 큐에 들어가게 된다. NIO() 를 이용하여 작업처리를 하기 때문에 논블로킹 방식으로 동작이 가능하다.

project reactor는 Reactive Streams() 명세를 따른 라이브러리이기 때문에 비동기, 논블로킹이 특징이다. reactor의 공식 홈페이지()에 가면 대표 특징으로 'fully non-blocking'이라고 잘 써놨다. 각각의 특징에 대해서 다시 한번 의미를 짚어보자.

국어사전을 찾아보면 여기서 '동'은 '같을 동' 을 사용하며 '기'는 '기약할 기'를 사용한다. 잘 정리된 것이 있나 찾아보던 중 동기와 비동기 개념을 프로그래밍에 접목하지 않고, 실제로 협업하는 협업과정에 적용해서 설명한 글()을 찾았는데 매우 흥미롭다. 동기와 비동기라는 개념 자체가 태생이 프로그래밍인 것으로 알고 있었는데, 이걸 보니 그게 아니라 원래 존재했던 개념이었나 싶기도 하다.

이 이슈에 관해서는 잘 정리된 글이 너무 많은데, 개인적으로 이 글()이 시각화해서 개념을 정리를 잘 해둔 것 같아서 링크를 달아둔다. 이 포스팅은 IBM의 글() 을 한글화 해서 정리해둔 것 같은데, 원문이 아무래도 이해하기엔 더 좋을 것 같다.

https://brunch.co.kr/@myner/47
https://www.reactive-streams.org/
https://projectreactor.io/
https://www.getguru.com/reference/synchronous-vs-asynchronous-communication
https://jh-7.tistory.com/25
https://developer.ibm.com/articles/l-async/
https://www.youtube.com/watch?v=I0zMm6wIbRI