java进阶—线程安全问题

news2025/7/29 23:51:47

线程安全问题，就涉及到一个资源共享，资源共享很好理解，就是多个线程同时操作一个资源池

就比如，快五一了，12306 购票，假设从北京到上海的高铁票一共只有200 张，现在3个人同时在线抢票，可以把一个人的app理解成一个线下窗口，这样在没有处理线程安全的情况下，就会出现抢到同一张票的可能性

我们用代码来简单模拟下

public class Ticket implements Runnable {

    // 三个窗口共享票200
    private Integer ticketCount = 200;

    @Override
    public void run() {
        while (true) {
            if (ticketCount > 0) {
                System.out.println(Thread.currentThread().getName() + "售出一张票,票号:"+ticketCount+"余票" + --ticketCount);
            } else {
                System.out.println("售罄");
                break;
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Ticket ticket = new Ticket();
        //窗口1
        Thread thread = new Thread(ticket);
        thread.setName("窗口1");
        //窗口2
        Thread thread2 = new Thread(ticket);
        thread2.setName("窗口2");
        //窗口3
        Thread thread3 = new Thread(ticket);
        thread3.setName("窗口3");

        thread.start();
        thread2.start();
        thread3.start();

    }

输出结果

在这里插入图片描述

可以看到，票号为200 的这张票，同时被三个人抢到，一个位置不可能三个人一起坐吧

来看线程安全会造成的另一种情况


public class Ticket implements Runnable {


    private Integer ticketCount = 200;

    @Override
    public void run() {
        while (true) {
            if (ticketCount > 0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "售出一张票,票号:"+ticketCount+"余票" + --ticketCount);
            } else {
                System.out.println("售罄");
                break;
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Ticket ticket = new Ticket();
        //窗口1
        Thread thread = new Thread(ticket);
        thread.setName("窗口1");
        //窗口2
        Thread thread2 = new Thread(ticket);
        thread2.setName("窗口2");
        //窗口3
        Thread thread3 = new Thread(ticket);
        thread3.setName("窗口3");

        thread.start();
        thread2.start();
        thread3.start();

    }

}

在这里插入图片描述
我在售票前，让线程休眠100毫秒，我们执行看看

在这里插入图片描述
可以发现，出现了零票,负票，你要是不介意扒车底，那你拿负票去车底，也不是不行

这里先说明一点，这里加了sleep，并不说明加了才出现错票的线程问题，为了演示，我们只是把概率提升了，不加也会出现

总结一下问题产生原因：当A一个线程进入程序，A并未操作完成，B线程也参与进来，操作同一个资源，就出现了线程安全问题

怎么解决线程安全问题呢？

其实在我们生活中，解决线程安全的例子随处可见

比如，你去上厕所，一个坑位一个人，你刚蹲进去，刚好另一个人也很着急，他刚好也进去了，这就出事了，解决办法，是不是给厕所上了锁，你进去，锁住，别人只能等，等你出来他才能进去

java 线程也是一样，解决线程安全问题，很简单，加锁

线程的锁，用一个关键字代表 Synchronized ，也可以叫做同步

同步有两种方式

同步代码块


synchronized(同步监视器){
   //需要同步代码
}

同步监视器：就是锁，任何一个类型的对象，但是这个锁就一个，多个线程共用这一个（一定要注意）

需要同步代码：操作共享数据的代码

回过头来看我们上述买票的例子，我们给他上个锁


public class Ticket implements Runnable {


    private Integer ticketCount = 200;
    Object object =new Object();
    @Override
    public void run() {
        while (true) {
            synchronized (object) {
                if (ticketCount > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "售出一张票,票号:"+ticketCount+"余票" + --ticketCount);
                } else {
                    System.out.println("售罄");
                    break;
                }
            }

        }
    }

    public static void main(String[] args) throws InterruptedException {
        Ticket ticket = new Ticket();
        //窗口1
        Thread thread = new Thread(ticket);
        thread.setName("窗口1");
        //窗口2
        Thread thread2 = new Thread(ticket);
        thread2.setName("窗口2");
        //窗口3
        Thread thread3 = new Thread(ticket);
        thread3.setName("窗口3");

        thread.start();
        thread2.start();
        thread3.start();

    }

}

在这里插入图片描述
输出结果：

在这里插入图片描述
可以看到票数到0 了，就算其他窗口还在执行，也是售罄状态

同步方法

同步方法：就是操作共享资源刚好是一个方法，我们可以直接在这个方法上同步

还是上述例子改造，我们先把方法提取出来，加上同步关键字

public class Ticket implements Runnable {


    private Integer ticketCount = 200;
    Object object =new Object();
    @Override
    public void run() {
        while (true) {
            sellTicket();
            if (ticketCount ==0) {
             System.out.println("售罄");
             break;
            }
        }
    }


    public  synchronized void  sellTicket() {
        if (ticketCount > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "售出一张票,票号:"+ticketCount+"余票" + --ticketCount);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Ticket ticket = new Ticket();
        //窗口1
        Thread thread = new Thread(ticket);
        thread.setName("窗口1");
        //窗口2
        Thread thread2 = new Thread(ticket);
        thread2.setName("窗口2");
        //窗口3
        Thread thread3 = new Thread(ticket);
        thread3.setName("窗口3");

        thread.start();
        thread2.start();
        thread3.start();

    }