线程安全问题-卖票案例实现

简介: 线程安全问题-卖票案例实现

需求:某电影院目前正在上映国产大片,共有100张票,而它有3个窗口买票,请设计一个程序模拟该电影院卖票

思路:

1.定义一个类Ticket实现Runnable接口,里面定义一个成员变量:private int ticketCount = 100;

2.在Ticket类中重写run()方法实现卖票,代码步骤如下

A:判断票数大于0,就卖票,并告知是哪个窗口卖的

B:票数要减1

C:卖光之后,线程停止

3.定义一个测试类TicketDemo,里面有main方法,代码步骤如下

A:创建Ticket类的对象

B:创建三个Thread类的对象,把Ticket对象作为构造方法的参数,并给出对应的窗口名称

C:启动线程

打印的顺序是随机的,是因为三个线程在争夺CPU运行权,这不影响程序的正确性

 

package threaddemo;
 
public class Demo {
    public static void main(String[] args) {
/*        Ticket ticket1 = new Ticket();
        Ticket ticket2 = new Ticket();
        Ticket ticket3 = new Ticket();
        Thread t1 = new Thread();
        Thread t2 = new Thread();
        Thread t3 = new Thread();*/
        Ticket ticket = new Ticket();
        Thread t1 = new Thread(ticket);
        Thread t2 = new Thread(ticket);
        Thread t3 = new Thread(ticket);
 
        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");
 
        t1.start();
        t2.start();
        t3.start();
    }
}
 
//*******************************
package threaddemo;
 
public class Ticket implements Runnable{
    private int ticket = 100;
 
    @Override
    public void run() {
        while (true){
            if (ticket == 0){
                //卖完了
                break;
            }else {
                ticket --;
                System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticket +"张票");
            }
        }
    }
}

 

卖票案例的思考

刚才讲解了电影院卖票程序,好像没有什么问题。但是在实际生活中,售票时出票也是需要时间的,所以,在出售一张票的时候,需要一点时间的延迟,接下来我们去修改卖票的动作:每次出票时间100毫秒,用sleep()方法实现

加了延时之后

卖票出现了问题

相同的票出现了多次

出现了负数的票

 

package threaddemo;
//错误案例  窗口一在卖票,还剩下0张票
//窗口三在卖票,还剩下-1张票
//窗口二在卖票,还剩下-2张票
public class Ticket implements Runnable{
    private int ticket = 100;
 
    @Override
    public void run() {
        while (true){
            if (ticket <= 0){
                //卖完了
                break;
            }else {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                ticket --;
                System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticket +"张票");
            }
        }
    }
}
 
//**************************分隔符
 
package threaddemo;
//错误案例  窗口一在卖票,还剩下0张票
//窗口三在卖票,还剩下-1张票
//窗口二在卖票,还剩下-2张票
public class Ticket implements Runnable{
    private int ticket = 100;
 
    @Override
    public void run() {
        while (true){
            if (ticket <= 0){
                //卖完了
                break;
            }else {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                ticket --;
                System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticket +"张票");
            }
        }
    }
}

判断条件是 if (ticket == 0)的话,它有时候会一直执行,停不下来

package threaddemo;
//错误案例  窗口二在卖票,还剩下-167张票
//窗口一在卖票,还剩下-168张票
//窗口二在卖票,还剩下-169张票
//窗口三在卖票,还剩下-170张票
//窗口一在卖票,还剩下-171张票
//窗口二在卖票,还剩下-172张票
//窗口三在卖票,还剩下-173张票
public class Ticket implements Runnable{
    private int ticket = 100;
 
    @Override
    public void run() {
        while (true){
            if (ticket == 0){
                //卖完了
                break;
            }else {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                ticket --;
                System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticket +"张票");
            }
        }
    }
}
 
//************************
package threaddemo;
 
public class Demo {
    public static void main(String[] args) {
/*        Ticket ticket1 = new Ticket();
        Ticket ticket2 = new Ticket();
        Ticket ticket3 = new Ticket();
        Thread t1 = new Thread();
        Thread t2 = new Thread();
        Thread t3 = new Thread();*/
        Ticket ticket = new Ticket();
        Thread t1 = new Thread(ticket);
        Thread t2 = new Thread(ticket);
        Thread t3 = new Thread(ticket);
 
        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");
 
        t1.start();
        t2.start();
        t3.start();
    }
}

 

卖票案例数据安全问题的解决

为什么会出现问题?(这也是我们判断多线程程序是否会有数据安全问题的标准)

多线程操作共享数据

如何解决多线程安全问题呢?

基本思想:让程序没有安全问题的环境

怎么实现呢?

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

Java提供了同步代码块的方式来解决

同步代码块

锁多条语句操作共享数据,可以使用同步代码块实现

synchronized(任意对象){

多条语句操作共享数据的代码

}

默认情况是打开的,只要有一个线程进去执行代码了,锁就会关闭

同步的好处和弊端

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

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

package threaddemo;
//错误案例  窗口二在卖票,还剩下-167张票
//窗口一在卖票,还剩下-168张票
//窗口二在卖票,还剩下-169张票
//窗口三在卖票,还剩下-170张票
//窗口一在卖票,还剩下-171张票
//窗口二在卖票,还剩下-172张票
//窗口三在卖票,还剩下-173张票
public class Ticket implements Runnable{
    private int ticket = 100;
    private Object obj = new Object();
    @Override
    public void run() {
        while (true){
            synchronized (obj){//多个线程必须使用同一把锁
                if (ticket == 0){
                    //卖完了
                    break;
                }else {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    ticket --;
                    System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticket +"张票");
                }
            }
        }
    }
}
 
//********************************************
package threaddemo;
 
public class Demo {
    public static void main(String[] args) {
/*        Ticket ticket1 = new Ticket();
        Ticket ticket2 = new Ticket();
        Ticket ticket3 = new Ticket();
        Thread t1 = new Thread();
        Thread t2 = new Thread();
        Thread t3 = new Thread();*/
        Ticket ticket = new Ticket();
        Thread t1 = new Thread(ticket);
        Thread t2 = new Thread(ticket);
        Thread t3 = new Thread(ticket);
 
        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");
 
        t1.start();
        t2.start();
        t3.start();
    }
}


目录
相关文章
|
18天前
多线程案例-定时器(附完整代码)
多线程案例-定时器(附完整代码)
254 0
|
6天前
|
设计模式 监控 Java
Java多线程基础-11:工厂模式及代码案例之线程池(一)
本文介绍了Java并发框架中的线程池工具,特别是`java.util.concurrent`包中的`Executors`和`ThreadPoolExecutor`类。线程池通过预先创建并管理一组线程,可以提高多线程任务的效率和响应速度,减少线程创建和销毁的开销。
25 2
|
6天前
|
安全 Java
Java多线程基础-10:代码案例之定时器(一)
`Timer` 是 Java 中的一个定时器类,用于在指定延迟后执行指定的任务。它常用于实现定时任务,例如在网络通信中设置超时或定期清理数据。`Timer` 的核心方法是 `schedule()`,它可以安排任务在延迟一段时间后执行。`
26 1
|
18天前
|
Python
Python学习之路 02 之分支结构
Python学习之路 02 之分支结构
459 0
Python学习之路 02 之分支结构
|
18天前
|
Java Python 开发者
Python 学习之路 01基础入门---【Python安装,Python程序基本组成】
线程池详解与异步任务编排使用案例-xian-cheng-chi-xiang-jie-yu-yi-bu-ren-wu-bian-pai-shi-yong-an-li
478 3
Python 学习之路 01基础入门---【Python安装,Python程序基本组成】
|
18天前
|
Java
线程池详解与异步任务编排使用案例-xian-cheng-chi-xiang-jie-yu-yi-bu-ren-wu-bian-pai-shi-yong-an-li
线程池详解与异步任务编排使用案例-xian-cheng-chi-xiang-jie-yu-yi-bu-ren-wu-bian-pai-shi-yong-an-li
54 0
|
5天前
|
设计模式 安全 Java
多线程(代码案例: 单例模式, 阻塞队列, 生产者消费者模型,定时器)
多线程(代码案例: 单例模式, 阻塞队列, 生产者消费者模型,定时器)
17 2
|
6天前
|
存储 Java 调度
Java多线程基础-11:工厂模式及代码案例之线程池(二)
这篇内容介绍了Java多线程基础,特别是线程池中的定时器和拒绝策略。
19 0
|
6天前
|
Java 调度
Java多线程基础-10:代码案例之定时器(二)
Java 多线程基础中,定时器(Timer)的实现通常使用 `PriorityBlockingQueue` 和 `wait/notify` 机制来管理任务。
14 0
|
6天前
|
存储 安全 Java
Java多线程基础-9:代码案例之阻塞队列(二)
Java多线程基础教程系列中,介绍了如何实现一个简单的阻塞队列(非泛型版本)。
17 0