폴백이 있는 동시 가격 조회

FxDart 승 async

요구사항

여섯 줄짜리 주문에 가격을 매기세요. 각 SKU는 실시간 가격 서비스에서 조회하되 — 동시에 최대 세 건까지만 진행 — 이 서비스는 일부 SKU를 갖고 있지 않아 그 경우 null을 반환하며, 해당 줄은 항목에 실려 있는 카탈로그 정가로 대체합니다. 가격이 매겨진 각 줄을 순서대로(폴백 여부 표시와 함께) 출력하고, 폴백 건수, 주문 합계, 관측된 최대 동시성을 출력하세요. 모든 데이터는 아래 코드에 있습니다.

FxDart 체인은 concurrent(3) 아래에서 조회를 수행한 다음, 두 번째 map이 평범한 ??로 폴백을 적용합니다 — 복구 정책은 제한된 fetch 다음에 오는 또 하나의 파이프라인 단계일 뿐입니다.

예상 출력

priced 6 items, 3 lookups at a time:
  SKU-100 x2 @ $8.49
  SKU-205 x1 @ $24.50 (catalog fallback)
  SKU-317 x3 @ $3.99
  SKU-408 x1 @ $119.00
  SKU-512 x4 @ $2.80 (catalog fallback)
  SKU-620 x2 @ $14.20
fallbacks used: 2
order total: $212.05
max lookups in flight: 3

나란히 보기

네이티브 Dart

class Item {
  final String sku;
  final int qty;
  final double listPrice; // catalog fallback
  const Item(this.sku, this.qty, this.listPrice);
}

const items = [
  Item('SKU-100', 2, 9.99), Item('SKU-205', 1, 24.50),
  Item('SKU-317', 3, 4.25), Item('SKU-408', 1, 129.00),
  Item('SKU-512', 4, 2.80), Item('SKU-620', 2, 15.75),
];

int inFlight = 0;
int maxInFlight = 0;

/// The live pricing service; some SKUs are missing from it (null).
Future<double?> lookupPrice(String sku) async {
  inFlight++;
  if (inFlight > maxInFlight) maxInFlight = inFlight;
  await Future.delayed(const Duration(milliseconds: 15));
  inFlight--;
  const live = {
    'SKU-100': 8.49, 'SKU-317': 3.99, 'SKU-408': 119.00, 'SKU-620': 14.20,
  };
  return live[sku];
}

/// Worker pool: [limit] workers share a cursor, results keep input order.
Future<List<(Item, double, bool)>> priceAll(List<Item> all, int limit) async {
  final results = List<(Item, double, bool)?>.filled(all.length, null);
  var next = 0;
  Future<void> worker() async {
    while (next < all.length) {
      final i = next++;
      final live = await lookupPrice(all[i].sku);
      results[i] = (all[i], live ?? all[i].listPrice, live == null);
    }
  }

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

Future<void> main() async {
  final priced = await priceAll(items, 3);
  print('priced ${priced.length} items, 3 lookups at a time:');
  for (final (it, price, fellBack) in priced) {
    print('  ${it.sku} x${it.qty} @ \$${price.toStringAsFixed(2)}'
        '${fellBack ? ' (catalog fallback)' : ''}');
  }
  print('fallbacks used: ${priced.where((r) => r.$3).length}');
  final total = priced.fold(0.0, (sum, r) => sum + r.$2 * r.$1.qty);
  print('order total: \$${total.toStringAsFixed(2)}');
  print('max lookups in flight: $maxInFlight');
}

FxDart

import 'package:fxdart/fxdart.dart';

class Item {
  final String sku;
  final int qty;
  final double listPrice; // catalog fallback
  const Item(this.sku, this.qty, this.listPrice);
}

const items = [
  Item('SKU-100', 2, 9.99), Item('SKU-205', 1, 24.50),
  Item('SKU-317', 3, 4.25), Item('SKU-408', 1, 129.00),
  Item('SKU-512', 4, 2.80), Item('SKU-620', 2, 15.75),
];

int inFlight = 0;
int maxInFlight = 0;

Future<void> main() async {
  final priced = await fx(items)
      .toAsync()
      .map((it) async => (it, await lookupPrice(it.sku)))
      .concurrent(3)
      .map((r) => (r.$1, r.$2 ?? r.$1.listPrice, r.$2 == null))
      .toList();
  print('priced ${priced.length} items, 3 lookups at a time:');
  for (final (it, price, fellBack) in priced) {
    print('  ${it.sku} x${it.qty} @ \$${price.toStringAsFixed(2)}'
        '${fellBack ? ' (catalog fallback)' : ''}');
  }
  print('fallbacks used: ${fx(priced).filter((r) => r.$3).size()}');
  final total = fx(priced).sumBy((r) => r.$2 * r.$1.qty);
  print('order total: \$${total.toStringAsFixed(2)}');
  print('max lookups in flight: $maxInFlight');
}

차이가 나는 이유

폴백 자체는 두 버전 모두에서 쉽습니다 — ??는 Dart의 문법입니다. 순수 Dart에 없는 것은 그 앞 단계입니다: 입력 순서를 유지하며 한 번에 세 건씩 조회하려면 워커 풀 관용구(공유 커서, 미리 크기를 정한 슬롯, Future.wait)가 강제되고, 폴백 로직은 워커 본문 안에 파묻혀 가장 보기 힘들고 테스트하기 힘든 곳에 자리잡게 됩니다. FxDart 버전에서는 fetch와 복구가 하나의 체인 안에서 분리된, 눈에 보이는 두 단계입니다 — concurrent(3)이 제한을 담당하고, 다음 map이 정책을 담당합니다 — 그리고 요약 줄(폴백을 위한 filter + size, 합계를 위한 sumBy)은 사이트 전체가 가르치는 것과 같은 어휘를 재사용합니다.

벤치마크

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 374 µs

FxDart 395 µs

최대 메모리 무승부

네이티브 Dart 16.5 MB

FxDart 17.1 MB

N = 10,000

시간 무승부

네이티브 Dart 34.9 ms

FxDart 34.2 ms

최대 메모리 FxDart 승

네이티브 Dart 49.1 MB

FxDart 30.9 MB

N = 100,000

시간 무승부

네이티브 Dart 351.3 ms

FxDart 353.2 ms

최대 메모리 무승부

네이티브 Dart 81.1 MB

FxDart 80.8 MB

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