经典案例：卖票问题【线程同步】

一、案例需求

某个电影院上映了史诗级大片《回村的诱惑》，共有100张票，卖票窗口总共有三个。请设计一个程序模拟卖票的过程！

二、步骤分析

1、定义一个卖票的线程类实现Runnable接口，并且声明一个成员变量：private int ticket=100;

2、在run方法中，判断该票数是否大于0，就卖票，打印输出剩余票数和窗口；

3、一个线程执行完之后，票数减一；

4、如果票数<=0则停止售票；

5、创建一个测试类，在main方法中创建卖票类的对象；

6、创建三个Thread类，并将卖票类的对象传入。分别调用start()方法。

三、代码实现

SellTicket类：

public class SellTicet  implements Runnable{private int ticket = 100;@Overridepublic void run() {while (true){if (ticket<=0){break;}else{ticket--;System.out.println(Thread.currentThread().getName() + "出票成功，剩余："+ticket+" 张票");}}}
}

测试类：

public class DemoTest {public static void main(String[] args) {SellTicet sellTicet = new SellTicet();Thread t1 = new Thread(sellTicet);Thread t2 = new Thread(sellTicet);Thread t3 = new Thread(sellTicet);t1.setName("窗口一");t2.setName("窗口二");t3.setName("窗口三");t1.start();t2.start();t3.start();}
}

输出结果（部分截图）：

输出结果如上图所示，这似乎是非常完美的，当然由于Java的线程是抢占式的，所以输出的结果没有按照顺序来，所以结果是乱的。但是呢，现实生活中，出票也是需要时间的，所以我们就给线程增加一个睡眠时间去模拟这一情况。改进地方如下图所示

这个时候，输出结果就会出现非常惊人的效果：

输出结果出现了重复票，并且出现了负数票的情况。

四、问题分析

由于private int ticket=100 是一个共享数据。当多个线程访问下面这段代码块的时候。由于线程进入之后，都会休眠100ms，那么三个线程依次进来之后，就都会处于线程中的计时等待状态。当到了指定的时间之后，线程依次进行ticket--操作。

负票情况（假设此时ticket=1）：

假如“窗口一”线程执行了这行代码（ticket=0），但是没有打印出来，这时，“窗口二”线程也执行了这行代码（ticket=-1），这个时候窗口一抢到CPU执行权了，就从控制台打印了-1张票这种情况了。

同票情况（假设此时ticket=10）：

假如“窗口一”线程执行了这行代码（ticket=9），但是没有打印出来，这时，“窗口二”线程也执行了这行代码（ticket=8），这个时候窗口一抢到CPU执行权了，就从控制台打印了8张票，此时窗口二也抢到了CPU执行权，也从控制台打印了8张票这种情况了。

            if (ticket<=0){break;}else{try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}ticket--;System.out.println(Thread.currentThread().getName() + "出票成功，剩余："+ticket+" 张票");}

五、同步代码块的解决方案

出现了这种问题的原因：多个线程并发的访问同一块代码。

解决方案：把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可

具体代码实现：synchronized关键字

我们将刚才的SellTicket类进行改造，具体代码如下：

public class SellTicet  implements Runnable{private int ticket = 100;@Overridepublic void run() {while (true){synchronized (this){if (ticket<=0){break;}else{try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}ticket--;System.out.println(Thread.currentThread().getName() + "出票成功，剩余："+ticket+" 张票");}}}}
}

测试类不变，输出结果如下：

此时，就不会出现相同票数和负数票数的问题了。

六、同步代码块的利弊

好处：解决了多线程的数据安全问题

弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率

七、Lock锁

为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock。但需要注意的是：Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化

我们把上面的SellTicket类再进行改造：

import java.util.concurrent.locks.ReentrantLock;public class SellTicet  implements Runnable{private int ticket = 100;private ReentrantLock lock = new ReentrantLock();@Overridepublic void run() {while (true){lock.lock();if (ticket<=0){break;}else{try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}ticket--;System.out.println(Thread.currentThread().getName() + "出票成功，剩余："+ticket+" 张票");}lock.unlock();}}}

测试类不变，结果与上图结果一致。

但是由于我们是手动去加锁和释放锁。难免出现如果锁还没得及释放，加锁的代码中出现了异常，那么程序就会进入阻塞状态，所以我们最好把释放锁放在finally的地方，这样子代码就显得比较优雅了。

    @Overridepublic void run() {while (true){lock.lock();try {if (ticket<=0){break;}else{Thread.sleep(100);ticket--;System.out.println(Thread.currentThread().getName() + "出票成功，剩余："+ticket+" 张票");}} catch (InterruptedException e) {e.printStackTrace();} finally {lock.unlock();}}}

好了，这就是线程同步问题中最经典的案例，感谢你的阅读！