【Java】隐式锁(synchronized)：如何解决餐厅等座的并发难题

当你走进一家熙熙攘攘的餐厅，准备享受一顿美味的晚餐时，你是否曾想过，这里正上演着一场场微观的线程战争？在这个场景中，每一张桌子都代表着珍贵的共享资源，而每一位顾客（线程）都在争夺这些资源的使用权。本文将带你深入这场战争的幕后，揭示隐式锁在多线程环境下可能遇到的困境，并提供一系列巧妙的解决策略。准备好，让我们一起探索这场餐桌上的并发之旅吧！

问题1：死锁 - 等座的僵局

两组顾客各自占据了两个相邻的空位，每组都在等待另一组离开以便扩大座位。这就像两个线程各自持有对方需要的锁，导致双方都无法继续执行。

解决方案: 确保所有顾客都使用同一个锁来等待和就座，我们可以避免死锁的发生。

public class Restaurant {
    private final Object tableLock = new Object();

    public void seatCustomer1(Customer customer) {
        synchronized (tableLock) {
            // 检查桌子是否空着
            // 安排顾客1就座
        }
    }

    public void seatCustomer2(Customer customer) {
        synchronized (tableLock) {
            // 检查桌子是否空着
            // 安排顾客2就座
        }
    }
}

问题2：资源竞争 - 抢桌大战

餐厅里的每张桌子都很抢手，多个顾客可能都想预订同一张桌子。这就像是多个线程竞争同一资源。

解决方案:使用AtomicInteger来管理可用桌子的数量，确保每次只有一个顾客能够成功预订。

import java.util.concurrent.atomic.AtomicInteger;

public class Restaurant {
    private final AtomicInteger availableTables = 
                        new AtomicInteger(restaurantCapacity);

    public boolean reserveTable() {
        return availableTables.getAndUpdate(i -> i > 0 ? i - 1 : i);
    }

    public void freeTable() {
        availableTables.incrementAndGet();
    }
}

问题3：可见性问题 - 实时更新餐桌状态

当服务员清理并准备一张新桌子时，其他顾客应该能够立即看到这个变化。这就像是线程需要看到其他线程对共享资源的更新。

解决方案:使用volatile关键字，我们确保了餐桌状态的可见性。

public class Restaurant {
    private volatile int availableTables = restaurantCapacity;

    public boolean reserveTable() {
        if (availableTables > 0) {
            availableTables--;
            return true;
        }
        return false;
    }

    public void freeTable() {
        availableTables++;
    }
}

问题4：线程饥饿 - 晚到的顾客

晚到的顾客可能会发现所有的好位置都被预订了，他们可能需要等待很长时间才能找到座位。

解决方案:使用LinkedBlockingQueue来维护等待列表，确保先到的顾客先得到服务，避免了饥饿现象。

import java.util.concurrent.LinkedBlockingQueue;

public class Restaurant {
    private final LinkedBlockingQueue<QueuedCustomer> waitingList 
                                    = new LinkedBlockingQueue<>();

    public void addCustomer(QueuedCustomer customer) {
        waitingList.offer(customer);
    }

    public Customer nextCustomer() {
        try {
            return waitingList.take();
        } catch (InterruptedException e) {
            // 处理异常
            return null;
        }
    }
}
class QueuedCustomer {
    // 顾客信息
}

总结

通过这个餐厅等座的例子，我们形象地展示了隐式锁可能遇到的问题及其解决方案。在多线程环境中，正确的锁管理和同步策略对于确保资源的合理分配和系统的高效运行至关重要。通过选择合适的锁类型、优化锁的粒度、确保资源的公平访问，我们才可以设计出一个既高效又健壮的并发系统。