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

    }

输出结果

java进阶—线程安全问题_第1张图片

可以看到,票号为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();

    }

}

java进阶—线程安全问题_第2张图片
我在售票前,让线程休眠100毫秒,我们执行看看

java进阶—线程安全问题_第3张图片
可以发现,出现了零票,负票,你要是不介意 扒车底,那你拿负票去车底,也不是不行

这里先说明一点,这里加了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();

    }

}

java进阶—线程安全问题_第4张图片
输出结果:

java进阶—线程安全问题_第5张图片
可以看到票数 到0 了,就算其他窗口还在执行,也是售罄状态

  1. 同步方法

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

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

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

    }

java进阶—线程安全问题_第6张图片
结果是一样的,解决了线程安全问题

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

java进阶—线程安全问题_第7张图片
以上就是通过同步来解决线程安全的问题了,以后去上厕所,可以这么说,我去同步了,只有程序员才懂得梗

你可能感兴趣的:(java基础,java,开发语言,线程安全问题)