Two Users, One Action

package main

import (
	"fmt"
	"sync"
	"sync/atomic"
	"time"
)

const buyers = 5

// The gap between reading the seat count and writing it back, like a database round trip.
func gap() { time.Sleep(50 * time.Millisecond) }

// run lets every buyer try at the same moment and counts the results.
func run(buy func() bool) (sold, refused int) {
	var mu sync.Mutex
	var wg sync.WaitGroup
	for range buyers {
		wg.Add(1)
		go func() {
			defer wg.Done()
			ok := buy()
			mu.Lock()
			if ok {
				sold++
			} else {
				refused++
			}
			mu.Unlock()
		}()
	}
	wg.Wait()
	return sold, refused
}

func main() {
	fmt.Printf("1 seat left, %d people press Buy at the same moment\n", buyers)

	// Check, then buy: two separate steps with a gap between them.
	var seats atomic.Int64
	seats.Store(1)
	sold, refused := run(func() bool {
		left := seats.Load() // read
		gap()
		if left < 1 { // check
			return false
		}
		seats.Store(left - 1) // write
		return true
	})
	fmt.Printf("%-28s sold %d, refused %d, seats left %d\n", "check, then buy:", sold, refused, seats.Load())

	// Check and buy as one step: a lock lets only one buyer in at a time.
	var lock sync.Mutex
	left := 1
	sold, refused = run(func() bool {
		lock.Lock()
		defer lock.Unlock()
		gap()
		if left < 1 {
			return false
		}
		left--
		return true
	})
	fmt.Printf("%-28s sold %d, refused %d, seats left %d\n", "check and buy as one step:", sold, refused, left)
}

const BUYERS = 5;

// The gap between reading the seat count and writing it back, like a database round trip.
const gap = () => new Promise((resolve) => setTimeout(resolve, 50));

// run lets every buyer try at the same moment and counts the results.
async function run(buy) {
  const results = await Promise.all(Array.from({ length: BUYERS }, buy));
  const sold = results.filter(Boolean).length;
  return [sold, BUYERS - sold];
}

async function main() {
  console.log(`1 seat left, ${BUYERS} people press Buy at the same moment`);

  // Check, then buy: two separate steps with a gap between them.
  // Node runs one thing at a time, but every await lets another buyer in.
  let seats = 1;
  let [sold, refused] = await run(async () => {
    const left = seats; // read
    await gap();
    if (left < 1) return false; // check
    seats = left - 1; // write
    return true;
  });
  console.log(`${"check, then buy:".padEnd(28)} sold ${sold}, refused ${refused}, seats left ${seats}`);

  // Check and buy as one step: a lock (a queue of promises) lets only one buyer in at a time.
  let lock = Promise.resolve();
  let left = 1;
  [sold, refused] = await run(() => {
    const turn = lock.then(async () => {
      await gap();
      if (left < 1) return false;
      left--;
      return true;
    });
    lock = turn;
    return turn;
  });
  console.log(`${"check and buy as one step:".padEnd(28)} sold ${sold}, refused ${refused}, seats left ${left}`);
}

main();

use std::sync::atomic::{AtomicI64, Ordering};
use std::sync::{Arc, Mutex};
use std::thread;
use std::time::Duration;

const BUYERS: usize = 5;

// The gap between reading the seat count and writing it back, like a database round trip.
fn gap() {
    thread::sleep(Duration::from_millis(50));
}

// Lets every buyer try at the same moment and counts the results.
fn run(buy: Arc<dyn Fn() -> bool + Send + Sync>) -> (usize, usize) {
    let handles: Vec<_> = (0..BUYERS)
        .map(|_| {
            let buy = buy.clone();
            thread::spawn(move || buy())
        })
        .collect();
    let sold = handles.into_iter().map(|h| h.join().unwrap()).filter(|ok| *ok).count();
    (sold, BUYERS - sold)
}

fn main() {
    println!("1 seat left, {BUYERS} people press Buy at the same moment");

    // Check, then buy: two separate steps with a gap between them.
    let seats = Arc::new(AtomicI64::new(1));
    let s = seats.clone();
    let (sold, refused) = run(Arc::new(move || {
        let left = s.load(Ordering::SeqCst); // read
        gap();
        if left < 1 {
            return false; // check
        }
        s.store(left - 1, Ordering::SeqCst); // write
        true
    }));
    println!("{:<28} sold {sold}, refused {refused}, seats left {}", "check, then buy:", seats.load(Ordering::SeqCst));

    // Check and buy as one step: a lock lets only one buyer in at a time.
    let left = Arc::new(Mutex::new(1));
    let l = left.clone();
    let (sold, refused) = run(Arc::new(move || {
        let mut left = l.lock().unwrap();
        gap();
        if *left < 1 {
            return false;
        }
        *left -= 1;
        true
    }));
    println!("{:<28} sold {sold}, refused {refused}, seats left {}", "check and buy as one step:", left.lock().unwrap());
}

import threading, time

BUYERS = 5


def gap():
    """The gap between reading the seat count and writing it back, like a database round trip."""
    time.sleep(0.05)


def run(buy):
    """Lets every buyer try at the same moment and counts the results."""
    results = []
    threads = [threading.Thread(target=lambda: results.append(buy())) for _ in range(BUYERS)]
    for t in threads:
        t.start()
    for t in threads:
        t.join()
    return results.count(True), results.count(False)


print(f"1 seat left, {BUYERS} people press Buy at the same moment")

# Check, then buy: two separate steps with a gap between them.
seats = 1


def check_then_buy():
    global seats
    left = seats  # read
    gap()
    if left < 1:  # check
        return False
    seats = left - 1  # write
    return True


sold, refused = run(check_then_buy)
print(f"{'check, then buy:':<28} sold {sold}, refused {refused}, seats left {seats}")

# Check and buy as one step: a lock lets only one buyer in at a time.
lock = threading.Lock()
left = 1


def check_and_buy():
    global left
    with lock:
        gap()
        if left < 1:
            return False
        left -= 1
        return True


sold, refused = run(check_and_buy)
print(f"{'check and buy as one step:':<28} sold {sold}, refused {refused}, seats left {left}")

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.BooleanSupplier;

public class Main {
    static final int BUYERS = 5;

    // The gap between reading the seat count and writing it back, like a database round trip.
    static void gap() {
        try { Thread.sleep(50); } catch (InterruptedException e) { throw new RuntimeException(e); }
    }

    // Lets every buyer try at the same moment and counts the results.
    static int[] run(BooleanSupplier buy) throws InterruptedException {
        AtomicInteger sold = new AtomicInteger();
        List<Thread> threads = new ArrayList<>();
        for (int i = 0; i < BUYERS; i++) {
            threads.add(Thread.startVirtualThread(() -> { if (buy.getAsBoolean()) sold.incrementAndGet(); }));
        }
        for (Thread t : threads) t.join();
        return new int[] {sold.get(), BUYERS - sold.get()};
    }

    public static void main(String[] args) throws InterruptedException {
        System.out.printf("1 seat left, %d people press Buy at the same moment%n", BUYERS);

        // Check, then buy: two separate steps with a gap between them.
        AtomicInteger seats = new AtomicInteger(1);
        int[] r = run(() -> {
            int left = seats.get(); // read
            gap();
            if (left < 1) return false; // check
            seats.set(left - 1); // write
            return true;
        });
        System.out.printf("%-28s sold %d, refused %d, seats left %d%n", "check, then buy:", r[0], r[1], seats.get());

        // Check and buy as one step: a lock lets only one buyer in at a time.
        ReentrantLock lock = new ReentrantLock();
        int[] left = {1};
        r = run(() -> {
            lock.lock();
            try {
                gap();
                if (left[0] < 1) return false;
                left[0]--;
                return true;
            } finally {
                lock.unlock();
            }
        });
        System.out.printf("%-28s sold %d, refused %d, seats left %d%n", "check and buy as one step:", r[0], r[1], left[0]);
    }
}