public class PutawayTaskRegistry {
    private final ConcurrentHashMap<Long, PutawayTask> runningTasks = new ConcurrentHashMap<>();

    public boolean register(PutawayTask task) {
        return runningTasks.putIfAbsent(task.id(), task) == null;
    }

    public void unregister(Long taskId) {
        runningTasks.remove(taskId);
    }
}

public class WaveDispatchQueue {
    private final BlockingQueue<WaveTask> queue = new ArrayBlockingQueue<>(1000);

    public void submit(WaveTask task) throws InterruptedException {
        queue.put(task);
    }

    public WaveTask take() throws InterruptedException {
        return queue.take();
    }
}

public void startWorkers() {
    for (int i = 0; i < 8; i++) {
        executor.execute(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                try {
                    WaveTask task = queue.take();
                    waveService.dispatch(task);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        });
    }
}

public class PutawayRuleHolder {
    private final CopyOnWriteArrayList<PutawayRule> rules = new CopyOnWriteArrayList<>();

    public List<PutawayRule> currentRules() {
        return rules;
    }

    public void reload(List<PutawayRule> latest) {
        rules.clear();
        rules.addAll(latest);
    }
}

public class RoutingPolicyCache {
    private final AtomicReference<RoutingPolicy> policyRef =
        new AtomicReference<>(RoutingPolicy.defaultPolicy());

    public RoutingPolicy current() {
        return policyRef.get();
    }

    public void refresh(RoutingPolicy latest) {
        policyRef.set(latest);
    }
}

public boolean refreshIfNewer(RoutingPolicy latest) {
    while (true) {
        RoutingPolicy current = policyRef.get();
        if (latest.version() <= current.version()) {
            return false;
        }
        if (policyRef.compareAndSet(current, latest)) {
            return true;
        }
    }
}

synchronized (binA) {
    synchronized (binB) {
        transfer();
    }
}

synchronized (binB) {
    synchronized (binA) {
        transfer();
    }
}

public void transfer(Bin from, Bin to) {
    Bin first = from.id() < to.id() ? from : to;
    Bin second = from.id() < to.id() ? to : from;

    synchronized (first) {
        synchronized (second) {
            doTransfer(from, to);
        }
    }
}

public ReconcileResult reconcile(long supplierId, LocalDate month) throws InterruptedException {
    CountDownLatch latch = new CountDownLatch(3);

    AtomicReference<List<Receipt>> receiptsRef = new AtomicReference<>();
    AtomicReference<List<Invoice>> invoicesRef = new AtomicReference<>();
    AtomicReference<List<Payment>> paymentsRef = new AtomicReference<>();

    executor.execute(() -> {
        try {
            receiptsRef.set(receiptService.query(supplierId, month));
        } finally {
            latch.countDown();
        }
    });

    executor.execute(() -> {
        try {
            invoicesRef.set(invoiceService.query(supplierId, month));
        } finally {
            latch.countDown();
        }
    });

    executor.execute(() -> {
        try {
            paymentsRef.set(paymentService.query(supplierId, month));
        } finally {
            latch.countDown();
        }
    });

    latch.await();
    return reconcileEngine.compare(receiptsRef.get(), invoicesRef.get(), paymentsRef.get());
}

public class CarrierTrackClient {
    private final Semaphore semaphore = new Semaphore(20);

    public TrackInfo queryTrack(String trackingNo) {
        boolean acquired = false;
        try {
            acquired = semaphore.tryAcquire(1, 2, TimeUnit.SECONDS);
            if (!acquired) {
                throw new BizException("承运商接口繁忙，请稍后重试");
            }
            return doQuery(trackingNo);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new BizException("查询被中断");
        } finally {
            if (acquired) {
                semaphore.release();
            }
        }
    }
}

public OrderDetail detail(long orderId) {
    CompletableFuture<Order> orderFuture =
        CompletableFuture.supplyAsync(() -> orderService.get(orderId), executor);

    CompletableFuture<InventoryView> inventoryFuture =
        CompletableFuture.supplyAsync(() -> inventoryService.viewByOrder(orderId), executor);

    CompletableFuture<TrackInfo> trackFuture =
        CompletableFuture.supplyAsync(() -> trackService.queryByOrder(orderId), executor);

    CompletableFuture<Receivable> receivableFuture =
        CompletableFuture.supplyAsync(() -> financeService.receivable(orderId), executor);

    CompletableFuture.allOf(orderFuture, inventoryFuture, trackFuture, receivableFuture).join();

    return new OrderDetail(
        orderFuture.join(),
        inventoryFuture.join(),
        trackFuture.join(),
        receivableFuture.join()
    );
}

CompletableFuture<TrackInfo> trackFuture =
    CompletableFuture
        .supplyAsync(() -> trackService.queryByOrder(orderId), executor)
        .exceptionally(e -> TrackInfo.empty("物流轨迹暂不可用"));

for (Long orderId : orderIds) {
    new Thread(() -> fulfillmentService.fulfill(orderId)).start();
}

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    8,
    16,
    60,
    TimeUnit.SECONDS,
    new ArrayBlockingQueue<>(1000),
    new ThreadFactory() {
        private final AtomicInteger index = new AtomicInteger();

        @Override
        public Thread newThread(Runnable r) {
            return new Thread(r, "fulfillment-worker-" + index.incrementAndGet());
        }
    },
    new ThreadPoolExecutor.CallerRunsPolicy()
);

public void fulfillBatch(List<Long> orderIds) {
    for (Long orderId : orderIds) {
        executor.execute(() -> {
            try {
                fulfillmentService.fulfill(orderId);
            } catch (Exception e) {
                fulfillmentLogService.recordFailed(orderId, e.getMessage());
            }
        });
    }
}

@Transactional
public void fulfill(Long orderId) {
    int affected = orderMapper.markFulfilling(orderId);
    if (affected != 1) {
        return;
    }

    inventoryService.reserve(orderId);
    warehouseTaskService.createPickTask(orderId);
    orderMapper.markFulfilled(orderId);
}

public ThreadPoolStats stats() {
    return new ThreadPoolStats(
        executor.getPoolSize(),
        executor.getActiveCount(),
        executor.getQueue().size(),
        executor.getCompletedTaskCount()
    );
}

public class InventorySyncJob implements Runnable {
    private boolean running = true;

    public void stop() {
        running = false;
    }

    @Override
    public void run() {
        while (running) {
            syncOnce();
        }
    }
}

public class InventorySyncJob implements Runnable {
    private volatile boolean running = true;

    public void stop() {
        running = false;
    }

    @Override
    public void run() {
        while (running) {
            syncOnce();
        }
    }
}

public class SyncCounter {
    private volatile int successCount;

    public void success() {
        successCount++;
    }
}

public class SyncCounter {
    private final AtomicInteger successCount = new AtomicInteger();

    public void success() {
        successCount.incrementAndGet();
    }
}

public class SyncCounter {
    private final LongAdder successCount = new LongAdder();

    public void success() {
        successCount.increment();
    }

    public long value() {
        return successCount.sum();
    }
}

public class InventorySnapshotCache {
    private final Map<String, Integer> cache = new HashMap<>();

    public synchronized void put(String key, Integer qty) {
        cache.put(key, qty);
    }

    public synchronized Integer get(String key) {
        return cache.get(key);
    }
}

public class InventorySnapshotCache {
    private final Object lock = new Object();
    private final Map<String, Integer> cache = new HashMap<>();

    public void put(String key, Integer qty) {
        synchronized (lock) {
            cache.put(key, qty);
        }
    }

    public Integer get(String key) {
        synchronized (lock) {
            return cache.get(key);
        }
    }
}