🖌️ Isolate는 무엇인가 ?

Concurrency and isolates | Flutter
Concurrency | Dart

이번 글에서는 Isolate에 대해서 다뤄보도록 하겠다.

Flutter로 개발하다 보면 자연스럽게 듣거나 찾아보게 되는 기능이 바로 Isolate 기능일 것이다.

Isolate가 무엇이며, 왜 필요한 기능인지, 어떻게 사용해야 하는지, 어떤 단점들이 있는지에 대해서 예제를 살펴보며 차근차근 글을 작성해 보도록 하겠다.

Isolate ?

먼저 Isolate는 무엇인지에 대해서 알아보도록 하자.

Isolate가 무엇인지 알아보기 위해 Dart 공식문서에서 내용을 확인해보았다.

Isolate는 Dart 프로그램에서 실행되는 고유한 작업 단위입니다. 각 Isolate는 자신만의 메모리와 실행 스레드를 가지고 있으며, 다른 Isolate와 직접 메모리를 공유하지 않습니다. 이는 일반적인 스레드 모델과 구별되는 점입니다.
Isolate 간 통신은 메시지 패싱을 통해 이루어집니다. 이로 인해 데이터 동기화 문제를 피할 수 있고, 각각의 Isolate가 독립적으로 동작할 수 있습니다.
메인 Isolate는 Flutter 애플리케이션의 주 UI 스레드와 연결됩니다. 복잡한 계산이나 파일 I/O 작업이 메인 Isolate에서 실행되면 UI가 느려질 수 있기 때문에, 이러한 작업을 다른 Isolate로 분리하여 실행하는 것이 권장됩니다.

위의 내용이 공식문서에서 설명하고 있는 내용인데, Isolate에 대한 개념을 처음 접한다면 당연히 한 번에 이해는 안되실거라 생각한다.

Isolate가 무엇인지에 대해서 좀 더 풀어서 정의해 보자면, Isolate는 Flutter, Dart에서 사용되는 일종의 독립된 실행 단위의 개념이다.

쉽게 말해서 하나의 프로그램 내에서 별도의 메모리(Memory) 공간과 스레드(Thread)를 가지는 독립적인 실행 환경을 의미하는 것이다.
별도의 메모리 공간에서 실행되는 환경이므로 당연히 Isolate 간에 메모리를 공유하지 않게 되며, 통신이 필요한 경우 메시지 패싱(Message Passing)을 통해 데이터를 주고 받을 수 있다.

지금까지의 설명을 보면 구조가 멀티스레딩과 유사하다고 볼 수 있어 간혹 Isolate를 멀티스레드로 설명하는 글들이 있는데, 멀티스레드의 복잡성과 동기화 문제를 피하면서도 보다 안전한 병렬 처리의 이점을 제공하기 위해 설계되었다는 것이 차이점이라 보시면 된다.

왜 필요한가 ?

Isolate에 대한 개념이 명확히 잡히지 않았더라도 아직은 전혀 문제될 것이 없기에 천천히 이해하면서 다음 내용들을 살펴보도록 하자.

Isolate가 무슨 기능인지는 알겠는데, 도대체 왜 필요할걸까 ?

이 부분을 이해하기 위해서는 Flutter, Dart의 작업 환경에 대한 이해가 필요하다.

Flutter는 Dart 언어로 개발되어진 프레임워크라는 부분은 이미 알고 있을 내용이고, 싱글 스레드(Single-threaded) 환경으로 실행된다는 것도 대부분의 Flutter 개발자라면 아는 내용이다.

즉, 싱글 스레드 환경에서 실행되어 지기에 메인 스레드(Main Thread) 또는 UI 스레드(UI Thread)라고 불리는 스레드가 이벤트 루프를 사용하여 비동기 작업을 처리하고, 비동기 작업이 완료되면 해당 작업의 콜백을 실행시키며, UI 업데이트에 대한 랜더링 작업을 실행하게 된다.

한 개의 단일 스레드가 화면을 그리고 데이터를 호출하며, 사용자 행동을 처리하고 복잡한 연산도 실행한다고 쉽게 생각해보면 이해가 될 것이다.

만일 실행이 지연되거나 큰 작업이 포함되어 있다면 UI가 버벅이는(Jank) 치명적인 문제가 발생할 수 있게된다.

과연 얼마만의 시간에 작업이 처리되어야 문제가 발생하지 않는걸까 ?

Flutter는 60프레임(최대 120프레임)에서 최적의 퍼포먼스를 목표로 하는데, 해당 프레임을 최적화하기 위해서 16ms마다 UI를 업데이트한다고 알려져있다.
매 초 60프레임이 랜더링 되어야 하기 때문에, 정확히는 16.67ms 내에 랜더링이 되어야 하는 것이고, 120프레임인 경우는 8.33ms 내에 업데이트가 되어야 최적의 UI 퍼포먼스를 보여줄 수 있는 것이다.

화면 업데이트가 해당 기준을 넘어서게 되면 화면 지연(Jank)이 발생하여 사용자에게 좋지 않은 경험을 제공하게 되며 성능 저하가 발생할 수 있게 된다.

이러한 문제들을 사전에 해결하여 최적의 퍼포먼스를 발휘하기 위해 CPU 집약적인 작업이나 대규모 데이터 처리 등의 복잡하고 무거운 작업을 메인 스레드(Main Thread)와 별도의 독립적인 환경에서 실행하여 Jank를 줄이고 애플리케이션의 응답성을 유지하는데 Isolate 개념이 필요한 것이다.

어떻게 다른가 ?

Isolate와 일반적인 작업은 어떻게 다른지를 간단한 예제로 살펴보도록 하자.

예제는 단순한 기능인데, CPU 집약적인 문제를 실행하는 데 있어 UI가 어떻게 반응하는지를 비교한 예제이다.

반복문을 사용한 결과를 표시해주는 단순한 기능인데, 이 때 결과 값을 반환하기 전까지 로딩 인디케이터를 노출시켜 UI의 차이점을 단번에 이해할 수 있도록 하였다.

while (index < 10000000000) {
	index++;
}

Nomal 작동 방식에는 UI가 멈추는 현상(즉시 작동하면 로딩 인티케이터가 안보임;)을 명확하게 나타내 주기 위해서 1초의 딜레이 후 작동하도록 하였고, Isolate 방식은 UI가 멈추지 않기에 즉시 작업을 진행하였다.

Nomal	Isolate

단순한 기능을 통해서도 Isolate 기능의 장점을 바로 알 수 있게 된다.

기능은 단순하더라도 100억 번의 반복문이 작동되기에 작업을 완료하기 까지는 매우 긴 시간이 필요하게 된다.

다른 예제를 보도록 하자.

이번 예제는 위에서 사용한 예제와 동일한 작업을 수행하는 기능이지만 UI가 멈추는 현상이 발생 했을 때에 사용자 이벤트가 어떻게 처리되는지를 비교한 예제이다.

Nomal	Isolate

Nomal 방식에서는 UI가 멈추고 이벤트에 대한 반응을 업데이트하지 못하다가 반복문이 종료 되었을 때에 업데이트가 되는 것을 확인할 수 있다. 만일 사용자 이벤트가 서버에 대한 요청이었다면 이는 심각한 상황을 초래할 수 있었을 것입니다.
반면 Isolate에서는 원활하게 UI 업데이트를 진행하는 것을 확인할 수 있다.

이렇게 CPU 집중 작업을 메인 스레드(Main Thread)에서 하게 되면 프레임을 최적화하기 위한 16ms(최대 8.3ms) 내에 UI 업데이트를 완료하지 못하기 때문에 UI가 멈추게 되는 것이다.
반면 Isolate를 사용하게 되면 별도의 독립적인 환경에서 작업을 진행하기에 UI 스레드(UI Thread)를 방해하지 않고 매끄러운 UI를 나타내 주면서 격리된 공간에서 작업이 가능한 것이다.

일단은 Isolate가 무엇이고, 왜 사용해야 하는지와 시각적으로 어떻게 차이가 있는지 어느 정도는 이해는 했을 것이라 생각한다.
*잘 모르겠다면, 사용 방법을 배우면서 이해하시면 됩니다 !

지금까지 살펴본 내용으로만 본다면 Isolate는 무조건 사용해야 하는 기능 처럼보인다.

메인 스레드(Main Thread)에 방해를 하지 않으면서도 얼마든지 복잡한 작업을 처리할 수 있는거 아닌가 ?

과연 무조건 사용해야 하는 기능일까 ..? 얼마나 복잡하고 무거운 작업이어야 할까 ..?

주의할 점

Isolate는 충분히 필요한 기능이고, 서비스를 안정적으로 구축하기 위한 훌륭한 해결책이 될 수도 있다.

하지만 주의해야 할 점과 어느 케이스에서 도입해야 할지 ? 등의 고민하여야 하는 문제들이 있다.

Isolate 기능을 필요로 하는 케이스에는 어떤 작업들이 있는지 먼저 알아보자.

대표적인 작업은 CPU 집약적인 작업들이 있다.

고해상도 이미지를 처리하는 작업이나, 대규모 파일의 직렬화/역직렬화, 복잡한 연산 작업 등이 대표적으로 CPU 자원을 많이 소모할 수 있는 작업이므로 메인 스레드(Main Thread)가 차단될 가능성이 있다고 한다. 그 외에도 수많은 작업들이 메인 스레드(Main Thread)에 영향을 미칠 수 있다.

그렇다고 해서 이 모든 작업들을 무조건 Isolate를 사용해야 한다는 것은 아니다.

Isolate로 구축하게 되면 고려해야 할 문제점들에는 어떤 것들이 있을까 ?

위에서도 설명한 내용이지만 Isolate는 별도의 독립된 메모리 공간을 사용하기에 직접적으로 메모리를 공유하지 못하고, 메시지 패싱(Message Passing)을 통해 공유를 해야한다.
메모리를 공유하지 못한다는 것은 간단하게 말해서 데이터를 공유하지 못한다는 것이다. 메시지 패싱(Message Passing)으로 데이터를 공유하기 위해 데이터 직렬화/역질렬화의 과정이 필요하게 되는데 이 때에 복잡한 데이터 구조를 패싱하게 되면 오히려 성능 저하가 발생할 수도 있어서 일반적으로 메시지 패싱(Message Passing)은 단순한 데이터만을 전송한다.

독립된 메모리 공간을 가진다는 의미를 보면 Isolate 생성시마다 새로운 메모리가 필요하다는 의미이기 때문에 한정적인 메모리를 사용하는 디바이스라면 제한적인 상황이 생길 수 있다.

이 외에도 디버깅, 테스트 환경, 동기화 타이밍 등의 고려해야 할 문제들이 있다.

실제로 Isolate를 사용하지 않고도 대부분의 기능을 작동시키는 데에는 문제가 없고 각 환경마다의 서비스 규모가 다르기 때문에 Isolate 도입시 수 많은 테스트와 디버깅 후 도입을 고려해보는 것을 추천한다.

사용 방법

본격적으로 Flutter에서 Isolate를 사용하는 방법에 대해서 알아보도록 하자.

Flutter에서는 spawn, compute 두 가지 방식으로 별도의 독립된 메모리 공간에서 작업을 수행할 수 있도록 해준다.

spawn, compute 모두 독립된 메모리 공간에서 작업을 수행할 수 있지만 각각의 방식에는 차이가 있다.

spawn은 Isolate를 직접 생성하고 제어할 수 있고, 독립적인 메모리(Memory) 공간과 스레드(Thread)를 가지고 실행되어 복잡하고 커스터마이징한 병렬 처리를 가능하게 해주는 기능이다. 반면, compute는 고수준의 API로 간단하게 함수 형태로 Isolate 기능을 사용할 수 있도록 하며, 시스템이 자동으로 Isolate의 생성과 관리를 처리해준다 (당연히 compute를 사용해도 독립적인 메모리와 스레드를 가짐).

즉 spawn을 사용하면 Isolate를 직접 생성하고 해제하는 등의 모든 관리를 개발자가 직접 구현해야 하며, 데이터의 전달은 메시지 패싱(Message Passing)을 통해서만 이루어진다. 반면 compute는 이러한 과정을 자동으로 처리해주고 결과를 메인 스레드(Main Thread)에 반환하게 된다.

단순한 병렬 작업은 compute로 처리할 수 있지만 복잡한 병렬 작업이 필요하다면 spawn을 사용하는 것이 더 적합하다.

spawn

우선 복잡한 spawn 사용 방법 부터 알아보도록 하자.

spawn 사용 방법을 알아야 compute 방식이 어떻게 작동 되는지를 단번에 이해할 수 있기 때문에 복잡한 것부터 배워보자 !

과정

spawn을 사용한 Isolate 실행 절차 및 설명을 간단하게 보도록 하자.

1. Isolate 생성

• spawn 함수를 사용해 새로운 Isolate 생성
• 실행될 코드를 정의하고, 필요한 데이터를 전달

2. 실행환경

• 독립된 메모리 공간과 스레드를 가짐으로 다른 Isolate와는 완전히 분리된 환경
• 메인 스레드(Main Thread)와는 메모리가 공유되지 않기에 변수나 객체를 직접적으로 공유 불가

3. 메시지 패싱 (Message Passing)

• 데이터 교환 및 전달이 가능하고, 작업 결과를 Main Isolate로 전달
• Send Port, Receive Port를 사용해 데이터 송/수신 진행

4. 작업실행

• 독립된 환경에서 할당된 작업을 수행
• 복잡한 계산, 파일 I/O, 이미지 처리 등의 작업

5. 작업 종료 및 자원 해제

• 작업이 완료되면 결과를 반환하고 자신을 종료하여 자원을 해제하고 메모리를 반납

간단하게 절차를 보면 위의 순서대로 작업을 수행해주면 된다.

spawn을 사용해 Isolate를 생성하게 되면 더 이상 사용이 필요하지 않는 시점에는 반드시 Isolate를 해제하여야 한다는 점을 꼭 기억하시길 바란다.

Main Isolate 외에 추가적으로 생성된 Isolate는 Dart VM의 GC(Garbage Collector) 대상이 아니고 내부 객체만 GC(Garbage Collector)의 대상이 되기 때문에 자동으로 해제되지 않아 리소스를 낭비하는 상황이 발생하지 않도록 주의하여야 한다.

Garbage Collection(GC) : 메모리 관리 기능으로 더 이상 사용하지 않는 객체를 찾아 자동으로 해제하는 역할

Code

spawn은 Dart 언어의 표준 라이브러리에 포함된 기능으로 별도로 패키지를 추가하지 않고 사용할 수 있다.

spawn 함수는 entryPoint, message를 필수로 설정해 주어야 한다.

entryPoint는 새로 생성된 Isolate에서 가장 먼저 실행되는 함수로 해당 Isolate가 수행할 작업을 정의해 주면 되고, message는 이 함수에 전달되는 초기 데이터로, entryPoint에 전달할 인자(argument)를 의미한다.

따라서, spawn 함수를 사용할 때 entryPoint에는 실행할 작업을 정의한 함수를, message에는 그 함수에 전달할 값을 설정해 주면 되는 것이다.

기본 형태는 아래 코드와 같이 사용할 수 있다.

Isolate.spawn(entryPoint, message);

entryPoint 함수를 만들어 보도록 하자.

Isolate에서 작동될 무거운 작업을 위해서 루프를 사용한 코드를 만들도록 하겠다.

static void _runIsolate(SendPort message) {
	int current = 0;
	while (current < 10000000000) {
      current++;
    }
}

이어서 데이터를 전달하기 위한 메시지 패싱(Message Passing)에 대해서도 코드를 통해 알아보도록 하자.

message에는 entryPoint의 인자 값을 설정하게끔 되어있는데, SendPort 객체를 사용할 수 있다.

entryPoint의 수행 작업의 결과를 반환하는 message를 추가해 보도록 하자.

SendPort 객체의 send 함수를 통해 데이터를 전달하여 반환할 수 있다.

  static void _runIsolate(SendPort message) {
    int current = 0;
    while (current < 10000000000) {
      current++;
    }
    message.send(current);
  }

반환된 결과를 수신하도록 해보자.

ReceivePort 객체의 sendPort를 spawn 생성시 사용할 수 있고, receivePort의 listen stream을 구독해 반환 결과를 수신 받으면 된다.

Future<void> _isolate() async {
	final ReceivePort receivePort = ReceivePort();
	Isolate.spawn(_runIsolate, receivePort.sendPort);
    receivePort.listen((message) {
      print(message);
    });
}

이번엔 spawn 생성시 메시지를 Isolate에 초기 값으로 전달해주는 방법에 대해서 알아보도록 하자.

send 함수는 Isolate로 부터 반환 데이터를 전달 받는 것이라면 이번엔 Isolate에 데이터를 넘겨주는 방법이다.

이러한 메시지 패싱(Message Passing)은 Dart 언어의 데이터 타입을 사용할 수 있으며 객체 또한 가능하다.

Isolate의 결과를 Main Isolate에서 전달 받을 필요가 없다면, SendPort 객체를 사용하지 않아도 되기에 아래 코드와 같이 사용할 수 있다.

  Future<void> _isolate() async {
    Isolate.spawn(_runIsolate, 99);
  }

  static void _runIsolate(int initialCount) {
    int current = initialCount;
    while (current < 10000000000) {
      current++;
    }
    print("current : $current, initialCount : $initialCount");
    // flutter: current : 10000000000, initialCount : 99
  }

문자형을 전달할 수도 있다.

Future<void> _isolate() async {
	Isolate.spawn(_runIsolate, "TYGER");
}

static void _runIsolate(String message) {
	print("$message Velog !!");
    // flutter: TYGER Velog !!
}

정수형, 문자형 외에도 데이터 타입은 모두 사용 가능하니 참고하시면 된다.

일반적으로 Isolate를 사용하면 결과를 받길 원할 것이다.
그러기 위해서는 SendPort 객체가 필요하기 때문에, Isolate에도 데이터를 전달하고 결과 값도 받기 위한 메시지 패싱(Message Passing)을 만들어 보도록 하자.

SendPort와 초기 값을 가지는 Map 데이터 구조를 사용해보자.

final ReceivePort receivePort = ReceivePort();
final Map<String, dynamic> _data = {
	"port": receivePort.sendPort,
	"count": 99,
};

타입캐스팅을 사용해 SendPort 객체를 전달 받아 send 함수에 결과를 반환해주면 된다.

static void _runIsolate(Map<String, dynamic> data) {
	SendPort sendPort = data["port"] as SendPort;
	int current = data["count"];
    while (current < 10000000000) {
      current++;
    }
    sendPort.send(current);
}

위에서 결과를 구독하는 것과 동일하게 SendPort를 생성한 ReceivePort 객체의 listen을 통해 수신하면 된다.

Future<void> _isolate() async {
	final ReceivePort receivePort = ReceivePort();
	final Map<String, dynamic> _data = {
      "port": receivePort.sendPort,
      "count": 99,
    };
    Isolate.spawn(_runIsolate, _data);
    receivePort.listen((message) {
      print(message);
    });
}

Map 데이터 구조를 사용한다면 당연히 class로 만들어 사용할 수도 있다.

class IsolateMessage {
  final SendPort sendPort;
  final int current;

  const IsolateMessage({
    required this.sendPort,
    required this.current,
  });
}

class를 사용해 IsolateMessage 객체를 만들어 준 뒤 사용할 수 있다.

Future<void> _isolate() async {
	final ReceivePort receivePort = ReceivePort();
	final IsolateMessage isolateMessage = IsolateMessage(sendPort: receivePort.sendPort, current: 99);
	Isolate.spawn(_runIsolate, isolateMessage);
	receivePort.listen((message) {
      	print("Result : $message");
        // flutter: Result : 10000000000
	});
}

IsolateMessage 객체를 사용해 SendPort의 send 함수를 사용해주면 된다.

static void _runIsolate(IsolateMessage message) {
    int current = message.current;
    while (current < 10000000000) {
      current++;
    }
    message.sendPort.send(current);
  }

Isolate의 메시지 패싱(Message Passing)을 사용하는 방법에 대해서 알아봤는데, 결과를 반환하는 send 함수에도 Dart 언어의 데이터 타입과 객체 모두 사용이 가능하다.

class를 만들어주자.

class IsolateResult {
  final int result;

  const IsolateResult({required this.result});
}

객체를 send 함수에 패싱할 수 있다.

static void _runIsolate(IsolateMessage message) {
	int current = message.current;
    while (current < 10000000000) {
      current++;
    }
    IsolateResult result = IsolateResult(result: current);
    message.sendPort.send(result);
}

메시지 패싱(Message Passing)은 Isolate 간에 데이터를 주고받는 유일한 방법이고, 메모리를 공유하지 않기 때문에 SendPort, ReceivePort를 통해서만 전달할 수 있다는 점을 이해하고 있으면 된다.

하지만 데이터가 복잡하거나 데이터의 크기가 크다면 직렬화/역직렬화시 Main Isolate가 이를 처리하는 동안 지연(Jank)이 발생해 UI가 느려지거나 버벅일 수 있어 성능에 영향을 미치지 않도록 충분히 고려하여 설계하여야 한다는 점을 주의하시면 좋을 것 같다.

만약에 메시지 패싱(Message Passing)을 사용해 Isolate간에 데이터를 주고 받지 않아도 되는 케이스라면 어떻게 사용할 수 있을까 ?

entryPoint에서 아무런 인자를 받지 않도록 하고 message를 null로 설정해주면 된다.
하지만 이렇게 사용하게 되면 Isolate의 작업을 확인할 수 없을 뿐만 아니라 Isolate내에서는 Main Isolate의 UI를 직접적으로 업데이트 할 수 없기 때문에 자주 사용되는 방법은 아니다.

 Future<void> _isolate() async {
    Isolate.spawn(_runIsolate, null);
}

static void _runIsolate(_) {
	int current = 0;
	while (current < 10000000000) {
      current++;
    }
}

그럼에도 메시지 패싱(Message Passing)을 사용할 필요가 없다면 참고하시면 좋을 것 같다. 왜냐하면 메시지 패싱(Message Passing)을 사용하지 않으면서 ReceivePort를 불필요하게 열어둘 필요는 없기 때문이다.

이어서 위에서도 언급한 내용이지만 추가로 생성된 Isolate는 Dart VM의 GC(Garbage Collector) 대상이 되지 않는다는 부분을 언급했었다.

반드시 개발자가 필요에 의해서 생성을 했다면 해제도 해주어야 한다는 의미이다.

해제를 하는 방법에 대해서 알아보도록 하겠다.

Isolate를 해제하는 방법은 간단하다. kill 함수만 사용해주면 된다.

아래 코드를 사용하려면 Isolate를 선언해야 한다.

isolate.kill();

Isolate는 Future 타입이기 때문에 생성시 인스턴스(Instance)를 반환하려면 await 키워드를 사용해 생성을 기다려야 한다.

final Isolate isolate = await Isolate.spawn(_runIsolate, null);

반환된 인스턴스(Instance)를 사용해 Isolate를 해제하여 메모리에서 제거할 수 있다.

final Isolate isolate = await Isolate.spawn(_runIsolate, null);
isolate.kill();

해제되는 시점이 중요하게 된다. 메시지 패싱(Message Passing)을 사용하는 경우라면 결과를 반환 받고 나서 해제가 되어야 한다.

ReceivePort를 Isolate 내에서 열어 두었기 때문에 메시지 결과를 받기 전에 먼저 Isolate가 해제된다면 ReceivePort의 결과가 수신되지 않는다.

ReceivePort의 수신을 받고나서 해제해주면 된다.

Future<void> _isolate() async {
    final ReceivePort receivePort = ReceivePort();
    final Isolate isolate =
        await Isolate.spawn(_runIsolate, receivePort.sendPort);
    receivePort.listen((message) {
      print(message);
      isolate.kill();
    });
}

메시지 패싱(Message Passing)을 사용할 때에 주의할 점이 한 가지 더 있는데, 바로 ReceivePort 또한 닫아줘야 한다는 것이다.

Isolate를 해제하게 되면 더 이상 사용되지 않는 ReceivePort는 GC(Garbage Collector)에 의해 자동으로 해제가 되지만 명시적으로 닫아주는 것이 좋다.

ReceivePort는 close 함수를 사용해 포트를 닫을 수 있다.

Future<void> _isolate() async {
	...
    receivePort.listen((message) {
      print(message);
      
      receivePort.close();
      isolate.kill();
    });
}

생성된 Isolate를 해제하고, 메시지 패싱(Message Passing)을 위한 ReceivePort를 닫아 자원을 명확히 해제하고, 메모리 누수를 방지하며, 코드의 안정성을 높힐 수 있다.

일부 Isolate가 반복적이거나 자주 생성되어야 한다면 매번 열고 닫는 것이 더 많은 메모리를 점유할 수 있기에 안정적인 해제 시점을 고려하여 효율적인 관리 방법을 고민해봐야 할 것이다.

spawn 방법의 옵셔널에 대해서도 살펴보도록 하자.

paused

paused는 Boolean 타입으로 Isolate의 실행 상태를 제어하는 데 사용된다. 기본 값은 false 상태이고, true로 설정한다면 spawn으로 Isolate를 생성할 때에 일시 정지 상태로 생성이 되어 명시적으로 실행을 하기 전까지는 대기 상태로 남아 있게된다.
Isolate 생성 후 초기화 작업이나 환경 설정 등의 작업이 필요한 경우 대기 상태로 전환하기 위해서 사용할 수 있다.

대기 상태를 해제하고 재개 하고 싶을 때에 resume 함수를 이용하면 된다.

Future<void> _isolate() async {
  final Isolate isolate = await Isolate.spawn(
    _entryPoint,
    message,
    paused: true,
  );
  isolate.resume(isolate.pauseCapability!);
}

resume 함수 사용시 생성된 Isolate의 pauseCapability를 사용해 권한을 제공하면 된다.

errorsAreFatal

해당 옵션은 생성된 Isolate의 오류가 발생한 경우 발생한 오류가 치명적(fetal)인지를 결정하는 역할을 한다.
Boolean 타입으로 기본 값은 true이며, 오류가 발생시 Isolate는 즉시 종료된다. 만일 즉시 종료가 되길 원하지 않는다면 false를 제공하면 되고 이 경우 Isolate는 계속 실행되기에 후속 작업을 별도로 해줘야 한다.

onExit

onExit는 명칭에서도 알 수 있듯이 Isolate 종료 시점을 수신하기 위한 파라미터이다. 해당 알림의 메시지는 특별한 값을 가지는 것은 아니며 kill 함수 실행시나 정상적으로 종료가 되었을 때에 호출을 받을 수 있다.
종료 시점을 호출 받기 때문에 필요한 후속 작업 등을 진행할 수 있다.

사용 방법은 위에서 배웠던 ReceivePort의 SendPort를 생성해서 사용할 수 있다. 여기서 중요한 부분은 spawn의 message의 포트와 서로 다른 포트를 사용해야 한다는 것이다.

Future<void> _isolate() async {
	final exitPort = ReceivePort();

	final Isolate isolate = await Isolate.spawn(
    	_entryPoint,
    	message,
    	onExit: exitPort.sendPort,
  	);

	exitPort.listen((_) {
    	exitPort.close();
  	});
}

onError

onError도 onExit와 사용 방법은 동일하고 에러 발생에 대한 정보는 자동으로 메시지로 전달해 주지만, send를 사용해 직접 전달 받을 수도 있다.
에러 발생시 errorsAreFatal의 설정에 따라 즉시 종료 시키거나 아니면 종료를 시키지 않을 수도 있는데, onExit의 종료 시점 등을 호출해서 테스트 해보면 에러에 따른 Isolate 상태를 확인할 수 있다.

Future<void> _isolate() async {
	final errorPort = ReceivePort();

	final Isolate isolate = await Isolate.spawn(
    	_entryPoint,
    	message,
    	onError: errorPort.sendPort,
  	);

	errorPort.listen((message) {
   		print("error : $message");
        // flutter: error : [type 'int' is not a subtype of type 'String' in type cast, #0   
        
    	errorPort.close();
  	});
}

debugName

마지막으로 debugName은 디버깅시 Isolate를 식별할 수 있는 식별자를 추가하는 설정이다. 디버깅 도구나 IDE 사용시 효율적으로 식별할 수 있다.

이외에도 생성한 Isolate의 인스턴스 메서드에도 다양한 기능들을 제공하고 있다.

addOnExitListener와 addErrorListener는 Isolate 생성 시 spawn 함수에서 제공하는 옵셔널 파라미터인 onExit와 onError와 동일한 기능을 합니다. 각각 Isolate가 종료될 때와 에러가 발생할 때 해당 SendPort로 알림을 보내는 역할을 하게되며, removeOnExitListener와 removeErrorListener는 각각 addOnExitListener와 addErrorListener로 추가한 리스너를 제거하는 데 사용됩니다.
errorsAreFatal의 기능과 동일한 setErrorsFatal 함수도 있다.

compute

이번엔 compute 방법에 대해서 알아보도록 하자.

compute는 고수준의 API로서 간단하게 함수 형태로 Isolate 기능을 사용할 수 있다. 즉 시스템이 자동으로 생성과 관리를 처리해준다.

구조 자체가 단순하고 심플한 형태이다.

compute는 내부적으로 Isolate의 생성 및 해제, ReceivePort, SendPort를 사용한 메시지 패싱(Message Passing)을 자동적으로 처리하기에 수행할 작업과 초기 데이터만 설정해주면 된다.

await compute(_callback, message);

callback에 수행할 작업을 만들어 주도록 하자.

spawn 사용시에는 ReceivePort, SendPort를 사용해 데이터를 전달 하였지만, compute는 함수 자체를 반환해주어야 한다.

static int _runIsolate(int value) {
	int current = value;
	while (current < 10000000000) {
      current++;
    }
    return current;
}

정수형 외에도 기본 데이터 타입은 인자 값이나 반환 값으로 사용할 수 있다.

int current = await compute(_runIsolate, 10);

compute는 비동기적으로 작동되기에 then, catchError 등의 기능을 사용해 처리하여도 된다.

자동으로 Isolate를 해제해 주기 때문에, spawn 방식과 비교하면 쉽게 구현이 가능하다는 장점은 있지만 커스터마이징 부분이나 제어의 한계가 있으니 기능의 규모나 복잡성, 여러 케이스 등을 고려해서 효율적인 방식으로 구축하면 좋을 것 같다.

마무리

이번 글에서 Isolate가 무엇이고, Flutter 개발을 위해서 왜 필요한 개념인지, 어떤 경우에 사용해야 도움이 되고, 주의할 점은 무엇인지에 대해서 순차적으로 작성해 보았다.

추가적으로 Isolate를 어떻게 사용해야 하는지에 대한 사용 방법도 알아보았다.

좀 더 시각적으로 쉽게 이해하고 실제로 적용해 볼 만한 기능들로 예제를 만들어 보려고 했지만 대부분의 케이스에서는 비동기 처리만으로도 충분히 이슈 없이 기능 작동이 가능하고 강제로 CPU 집약적인 작업을 추가해야만 Isolate 사용에 대한 시각적인 차이점이 나타나기 때문에 다양한 케이스의 예제를 만들지 못한 점이 아쉬운 부분이다.

이 부분은 실제로 사용될 만한 기능들을 여러 케이스를 고려하여 예제를 만들어 추가적으로 글을 작성하도록 하겠다.

Isolate에 대해서 잘못된 내용이 있거나 추가적으로 궁금하신 부분은 편하게 댓글 남겨주시면 확인 후 빠른 답변 드리도록 하겠습니다.

감사합니다 !

Sample App ..

Git Repository