Java 一个订单同时不能被两个人抢 怎么写

要求:
模拟商店商品上架和购买动作，首先，共享资源为商店货架同同一件商品可以摆放5件，创建2个服务员，创建2个顾客，同时开启4个线程，2个服务员线程负责往货架上添加商品，顾客负责消费。
上代码…
首先是商店类

public class Story {
    //商品名称
    private String name;
    //共享数据，用来记录当前货架上的商品数量，我们假设货架上只能摆放5件同样的商品。
    private int sum;
//add方法，服务员用来添加商品进入货架的方法。
    public void add() {
        //共享数据用同步代码块，用该类的字节码文字对象作为锁
            synchronized (Story.class) {
                //if判断语句，用来判断货架上的商品数量，如果是在这个范围，那是可以添加的。
                if (sum>=0&&sum<5) {
                    this.setName("1号商品");
                    //为当前的商品打上编号，同时也调用setSum()方法重置sum的值。
                    this.setSum(sum+1);
                    //添加进货架之后，打印显示已经添加。
                    System.out.println(Thread.currentThread().getName()+"已经把第"+this.getSum()+"件放入货架！");
                    //为了看出并发效果，我们添加完一件商品之后，让该服务员休息会，也就是让此线程放弃本次的执行权。
                    Thread.yield();
                }
            }
    }

    //此方法为消费者进店消费的方法
    public void sale() {
        //以下是操作功效数据的代码，用同步代码块封装
            synchronized (Story.class) {
                //判断货架上需要有商品才能消费，使用sum的值需要大于0
                if (sum > 0) {
//                    try {
//                        Thread.sleep(10);
//                    } catch (InterruptedException e) {
//                        e.printStackTrace();
//                    }
                    //消费之前，打印一下消费的编号
                    System.out.println(Thread.currentThread().getName() + "---已经购买了第" + this.getSum()+"件"+this.getName());
                    //编号表示减1
                    sum--;
                    //同样让消费者线程放弃本次执行权
                    Thread.yield();
                }
            }
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setSum(int sum) {
        this.sum = sum;
    }

    public int getSum() {
        return sum;
    }

    public String getName() {
        return name;
    }
}

然后就是服务员和消费者

/*
消费者，实现Runnable接口，复写run方法
* */
public class customer implements Runnable {
    Story story;
    //带参构造函数，初始化
    public customer(Story story){
        this.story = story;
    }

    @Override
    public void run() {
        //死循环，模拟用户购买消费
        while(true){
            story.sale();
        }

    }
}

/*
服务员类，实现runnable接口，复写run方法
* */
public class waiter implements Runnable{
    Story story ;
    //为保证商店的唯一性，创建对象是，用带参构造函数进行初始化。
    public  waiter(Story story){
        this.story = story;
    }

    @Override
    public void run() {
        //死循环添加商品至货架
        while(true){
            story.add();
        }
    }
}

最后main方法启动测试

public class bossTest {
    public static void main(String[] args) {
        //创建商定对象，这是是唯一的
        Story story = new Story();

        //创建服务员对象，用带参的构造函数，传入商店。
        waiter waiter1 = new waiter(story);
        waiter waiter2 = new waiter(story);

        //创建消费者对象，用带参构造函数，传入商店
        customer customer1 = new customer(story);
        customer customer2 = new customer(story);

        //创建四条并发进行的线程，分别传入服务员跟消费者。
        Thread t1 = new Thread(customer1,"消费者3号：");
        Thread t2 = new Thread(customer2,"消费者4号：");
        Thread t3 = new Thread(waiter1,"服务员1：");
        Thread t4 = new Thread(waiter2,"服务员2：");

        //开启线程
        t1.start();
        t2.start();
        t3.start();
        t4.start();

//        t1.setDaemon(true);
//        t2.setDaemon(true);
//        t3.setDaemon(true);
//        t4.setDaemon(true);

/*        for(int i =0;i<KAIGUAN;i++){
            if(i==60){
                t1.interrupt();
                t2.interrupt();
                t3.interrupt();
                t4.interrupt();
            }
        }*/
    }
}

效果