병렬 다운로드, 순서대로 결과 받기

FxDart 승 async

요구사항

파일 여섯 개를 다운로드하세요 — 각각 고정된 크기와 고정된(시뮬레이션된) 전송 시간을 가지며, 아래 코드에 있습니다 — 동시에 최대 세 개까지만 진행 중이도록 하고, 결과를 요청 순서대로 번호를 매겨 나열하세요. 완료 순서가 뒤섞이도록 지연 시간이 선택되어 있습니다: 30 ms 걸리는 video.mp4가 먼저 요청되지만 10 ms 걸리는 notes.txt가 먼저 끝납니다. 두 버전 모두 어떤 파일이 가장 먼저 끝났는지와 관측된 최대 동시성을 출력합니다 — 작업이 순서 없이 실제로 겹쳐 진행되었으면서도 목록은 순서대로 유지되었음을 증명합니다.

내부적으로는 순서가 뒤섞이지만 겉으로는 순서가 유지되는 이 보장이 바로 concurrent(3)이 하는 일입니다: 최대 세 개의 상류 항목을 동시에 평가하면서도 결과는 원본 순서대로 산출합니다. 체인은 zipWithIndex로 번호를 매기고 join으로 보고서를 조립합니다.

예상 출력

downloaded 6 files, 3 at a time, in request order:
  1. video.mp4 (900 KB)
  2. notes.txt (2 KB)
  3. slides.pdf (340 KB)
  4. photo.jpg (180 KB)
  5. data.csv (55 KB)
  6. theme.zip (260 KB)
first to finish: notes.txt
total size: 1737 KB
max downloads in flight: 3

나란히 보기

네이티브 Dart

class FileSpec {
  final String name;
  final int kb;
  final int ms; // fixed simulated transfer time
  const FileSpec(this.name, this.kb, this.ms);
}

const files = [
  FileSpec('video.mp4', 900, 30), FileSpec('notes.txt', 2, 10),
  FileSpec('slides.pdf', 340, 20), FileSpec('photo.jpg', 180, 30),
  FileSpec('data.csv', 55, 30), FileSpec('theme.zip', 260, 30),
];

int inFlight = 0;
int maxInFlight = 0;
final finished = <String>[];

Future<String> download(FileSpec f) async {
  inFlight++;
  if (inFlight > maxInFlight) maxInFlight = inFlight;
  await Future.delayed(Duration(milliseconds: f.ms));
  inFlight--;
  finished.add(f.name);
  return '${f.name} (${f.kb} KB)';
}

/// Worker pool: [limit] workers share a cursor; pre-sized slots keep the
/// results in request order even though completions interleave.
Future<List<String>> downloadAll(List<FileSpec> all, int limit) async {
  final results = List<String?>.filled(all.length, null);
  var next = 0;
  Future<void> worker() async {
    while (next < all.length) {
      final i = next++;
      results[i] = await download(all[i]);
    }
  }

await Future.wait([for (var i = 0; i < limit; i++) worker()]);
  return results.cast<String>();
}

Future<void> main() async {
  final results = await downloadAll(files, 3);
  print('downloaded ${files.length} files, 3 at a time, in request order:');
  for (var i = 0; i < results.length; i++) {
    print('  ${i + 1}. ${results[i]}');
  }
  print('first to finish: ${finished.first}');
  print('total size: ${files.fold(0, (sum, f) => sum + f.kb)} KB');
  print('max downloads in flight: $maxInFlight');
}

FxDart

import 'package:fxdart/fxdart.dart';

class FileSpec {
  final String name;
  final int kb;
  final int ms; // fixed simulated transfer time
  const FileSpec(this.name, this.kb, this.ms);
}

int inFlight = 0;
int maxInFlight = 0;
final finished = <String>[];

Future<void> main() async {
  final listing = await fx(files)
      .toAsync()
      .map(download)
      .concurrent(3)
      .zipWithIndex()
      .map((e) => '  ${e.$1 + 1}. ${e.$2}')
      .join('\n');
  print('downloaded ${files.length} files, 3 at a time, in request order:');
  print(listing);
  print('first to finish: ${finished.first}');
  print('total size: ${fx(files).sumBy((f) => f.kb)} KB');
  print('max downloads in flight: $maxInFlight');
}

차이가 나는 이유

Future.wait는 순서를 유지하지만 전부를 한꺼번에 다운로드합니다 — 제한이 없습니다. 제한을 추가하는 순간 네이티브 워커 풀이 필요해지고, 그 풀 아래에서 순서를 유지하는 것이 바로 까다로운 부분입니다: 공유 커서로 인덱싱되는, 미리 크기를 정해둔 results 리스트가 필요합니다. 슬롯 관리를 잘못하면 결과가 뒤섞여서 돌아옵니다 — 완료 순서가 요청 순서와 우연히 달라질 때만 드러나는 버그로, 타이밍에 좌우되어 테스트에서 놓치기 쉽습니다. FxDart에서는 순서 보장이 여러분의 코드가 아니라 연산자의 계약입니다: concurrent(3)은 타이밍이 어떻게 흐르든 항목을 순서 밖으로 반환할 수 없습니다.

벤치마크

Apple M1 Max, RAM 32 GB · Dart 3.12.2 (AOT 컴파일) · 2026-08-24

비동기 예제입니다. 대표 스케일이 1,000,000이 아니라 N = 100,000인 이유 — 원소 하나마다 양쪽 모두 이벤트 루프를 한 바퀴 돌아야 하므로, 실제 await 백만 번은 파이프라인이 아니라 Dart 이벤트 루프를 몇 분씩 재게 됩니다. 지연은 0으로 두고 예제의 동시성 제한은 그대로 유지합니다. 막대가 비교하는 것은 파이프라인 기계 장치 자체입니다.

N = 100

시간 무승부

네이티브 Dart 373 µs

FxDart 444 µs

최대 메모리 무승부

네이티브 Dart 16.5 MB

FxDart 17.1 MB

N = 10,000

시간 네이티브 승

네이티브 Dart 31.8 ms

FxDart 37.3 ms

최대 메모리 FxDart 승

네이티브 Dart 50.8 MB

FxDart 33.0 MB

N = 100,000

시간 네이티브 승

네이티브 Dart 338.8 ms

FxDart 380.5 ms

최대 메모리 네이티브 승

네이티브 Dart 80.9 MB

FxDart 92.8 MB

막대는 사이드별로 새 프로세스에서 반복 측정한 중앙값입니다(작은 N은 타이머 해상도를 위해 배치 처리). 두 사이드가 서로 5% 이내이거나 — 사람이 지각할 수 없는 차이인 0.6ms 이내이면 — 무승부로 칩니다. 상대 차이가 근소한 경우는 최대 5회까지 다시 측정합니다. 앱에서는 어느 막대가 짧든 몇 밀리초 이하의 차이는 사용자에게 보이지 않습니다. 메모리는 프로세스 최대 RSS입니다. Dart VM과 데이터셋은 양쪽이 동일하므로, 두 막대의 차이가 곧 파이프라인 자체가 붙들고 있는 양입니다.