재고 재평가, 조회는 한 번에 셋

FxDart 승 async

요구사항

창고에는 SKU, 보유 수량, 장부 가격을 가진 재고 품목들이 있습니다. 모든 단가를 가격 서비스에서 새로 받아 오되 — 동시 조회는 최대 셋 — 서비스가 모르는 SKU는 장부 가격으로 대체하세요. 재평가된 재고 총액과 대체 가격을 쓴 품목 수를 출력하세요. 서비스는 아래 코드에서 고정 지연으로 시뮬레이션되며, 두 버전 모두 예상 출력 아래에 표시된 줄들을 출력해야 합니다.

예상 출력

stock value: $4280.10
fallback prices used: 2
max lookups in flight: 3

나란히 보기

네이티브 Dart

class Stock {
  final String sku;
  final int qty;
  final double bookPrice;
  const Stock(this.sku, this.qty, this.bookPrice);
}

const stock = [
  Stock('KB-01', 12, 49.00),
  Stock('MS-77', 30, 19.50),
  Stock('HD-15', 8, 74.25),
  Stock('CB-02', 55, 4.80),
  Stock('MN-24', 6, 189.00),
  Stock('DK-31', 3, 320.00),
  Stock('WC-09', 21, 12.40),
];

int inFlight = 0;
int maxInFlight = 0;

/// The price service knows most SKUs — not all.
Future<double?> livePrice(String sku) async {
  inFlight++;
  if (inFlight > maxInFlight) maxInFlight = inFlight;
  await Future.delayed(const Duration(milliseconds: 15));
  inFlight--;
  const prices = {
    'KB-01': 45.00, 'MS-77': 21.00, 'HD-15': 69.90,
    'CB-02': 5.10, 'MN-24': 175.00,
  };
  return prices[sku];
}

Future<void> main() async {
  // Worker pool: shared cursor, pre-sized slots so order survives.
  final repriced =
      List<({int qty, double price, bool fb})?>.filled(stock.length, null);
  var cursor = 0;
  Future<void> worker() async {
    while (cursor < stock.length) {
      final i = cursor++;
      final s = stock[i];
      final live = await livePrice(s.sku);
      repriced[i] = (qty: s.qty, price: live ?? s.bookPrice, fb: live == null);
    }
  }

await Future.wait([worker(), worker(), worker()]);

var total = 0.0;
  for (final r in repriced) {
    total += r!.qty * r.price;
  }
  final fallbacks = repriced.where((r) => r!.fb).length;

print('stock value: \$${total.toStringAsFixed(2)}');
  print('fallback prices used: $fallbacks');
  print('max lookups in flight: $maxInFlight');
}

FxDart

import 'package:fxdart/fxdart.dart';

class Stock {
  final String sku;
  final int qty;
  final double bookPrice;
  const Stock(this.sku, this.qty, this.bookPrice);
}

int inFlight = 0;
int maxInFlight = 0;

Future<void> main() async {
  final repriced = await fx(stock)
      .toAsync()
      .attach((s) => livePrice(s.sku))
      .concurrent(3)
      .map((r) => (qty: r.$1.qty, price: r.$2 ?? r.$1.bookPrice, fb: r.$2 == null))
      .toList();

final total = fx(repriced).sumBy((r) => r.qty * r.price);
  final fallbacks = fx(repriced).countWhere((r) => r.fb);

print('stock value: \$${total.toStringAsFixed(2)}');
  print('fallback prices used: $fallbacks');
  print('max lookups in flight: $maxInFlight');
}

차이가 나는 이유

어려운 부분 둘이 여기 겹칩니다. 조회가 품목을 잃어버리면 안 됩니다 — attach는 각 재고 라인을 서비스가 돌려준 가격(또는 null) 옆에 붙잡아 두고, 그 덕에 대체 값 r.$2 ?? r.$1.bookPrice가 한 줄이 됩니다. 그리고 팬아웃은 제한되어야 합니다 — attach가 map과 같은 병렬 안전 기계를 타므로 concurrent(3)이 연산자로서의 제한입니다. 집계는 어휘에서 저절로 떨어집니다. 총액은 sumBy, 대체 횟수는 countWhere.

네이티브 버전은 그 전부를 지어야 합니다. 제한을 위한 공유 커서 워커 풀, 비동기 건너뛰기에서 입력이 살아남도록 손수 만든 (item, price) 레코드, 순서를 지키는 미리 크기 잡은 결과 슬롯, 그리고 개수를 위한 where(…).length 한 바퀴. 어느 것도 어렵지는 않습니다 — 전부가 네 단계짜리 과제를 파묻는 격식일 뿐입니다.

벤치마크

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

FxDart 381 µs

최대 메모리 무승부

네이티브 Dart 16.4 MB

FxDart 16.6 MB

N = 10,000

시간 네이티브 승

네이티브 Dart 30.5 ms

FxDart 34.1 ms

최대 메모리 FxDart 승

네이티브 Dart 49.0 MB

FxDart 31.1 MB

N = 100,000

시간 네이티브 승

네이티브 Dart 310.9 ms

FxDart 352.9 ms

최대 메모리 무승부

네이티브 Dart 80.8 MB

FxDart 80.5 MB

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