java进阶—线程安全问题

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

就比如，快五一了，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 ，也可以叫做同步

同步有两种方式

1. 同步代码块

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 了，就算其他窗口还在执行，也是售罄状态

2. 同步方法

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

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

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();

    }

结果是一样的，解决了线程安全问题

同步好处：解决线程安全问题，当然也会影响效率，同步的代码里只能有一个线程执行，其他等待，相当于一个单线程

以上就是通过同步来解决线程安全的问题了，以后去上厕所，可以这么说，我去同步了，只有程序员才懂得梗