为什么线程1一直在用着？

模拟售票的过程

这是 SEllTicketDemo

public class SellTicketDemo {
    public static void main(String[] args)
    {
        SellTicket st = new SellTicket();

        Thread thread1 = new Thread(st,"窗口1");
        Thread thread2 = new Thread(st,"窗口2");
        Thread thread3 = new Thread(st,"窗口3");

        thread2.setPriority(10);

        thread1.start();
        thread2.start();
        thread3.start();
    }
}

这是SellTicket类

public class SellTicket implements Runnable{
    private int ticket = 1;
    private Object object = new Object();
    @Override
    public void run() {
        while (true)
        {
            synchronized (object)
            {
                if(ticket<=100)
                {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() +":正在出售第" + ticket +"张票");
                    ticket++;
                }
                else
                {
                    System.out.println("已售完");
                }
            }
        }
    }
}

下面是运行的结果

synchronized (object)这个同步代码有问题，锁死了，别的线程进不去。把object改为this

package T13;

/**
 * 模拟车站售票系统
 * 
 * */
public class Ticket implements Runnable {

    //车票数量
    int ticketCount=100;
    @Override
    public void run() {
        saleTicket2();
    }
    //卖票
    public synchronized void saleTicket(){
        //临界点,要用互斥锁实现同步
        /**
         * 1.函数级的同步：synchronized
         * 2.语句块的同步：synchronized
         * */
        try{
            while(ticketCount>0){
                String name = Thread.currentThread().getName();
                ticketCount = ticketCount-1;
                System.out.println(name+"卖了一张票，还剩"+ticketCount+"张票");
                Thread.sleep(100);
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
    public void saleTicket2(){
        //临界点,要用互斥锁实现同步
        /**
         * 1.函数级的同步：synchronized
         * 2.语句块的同步：synchronized
         * */
        try{
            while(true){
                //需要锁，锁就是一个Object类型的变量
                synchronized (this) {//临界点
                    if(ticketCount<1)
                        break;
                    String name = Thread.currentThread().getName();
                    ticketCount = ticketCount-1;
                    System.out.println(name+"卖了一张票，还剩"+ticketCount+"张票");
                    Thread.sleep(10);
                }
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        new Thread(ticket,"售票员1").start();
        new Thread(ticket,"售票员2").start();
        new Thread(ticket,"售票员3").start();
        new Thread(ticket,"售票员4").start();
        
    }
}
 

您好，我是有问必答小助手，您的问题已经有小伙伴解答了，您看下是否解决，可以追评进行沟通哦~

如果有您比较满意的答案 / 帮您提供解决思路的答案，可以点击【采纳】按钮，给回答的小伙伴一些鼓励哦～～

ps:问答VIP仅需29元，即可享受5次/月 有问必答服务，了解详情>>>https://vip.csdn.net/askvip?utm_source=1146287632

非常感谢您使用有问必答服务，为了后续更快速的帮您解决问题，现诚邀您参与有问必答体验反馈。您的建议将会运用到我们的产品优化中，希望能得到您的支持与协助！

速戳参与调研>>>https://t.csdnimg.cn/Kf0y