线程：三个窗口卖票

最新推荐文章于 2023-03-03 11:35:37 发布
最新推荐文章于 2023-03-03 11:35:37 发布
阅读量247 收藏 2
点赞数
分类专栏： javaSE 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sunqianLOL/article/details/118073283
版权

卖票

package sq.com.exer;

/**
 * 例子：创建三个窗口卖票，总票数 100 张，使用实现 Runnable 接口的方式
 * 存在线程的安全问题，待解决
 *
 */
class Window extends Thread{

    private static int ticket = 100;

    @Override
    public void run() {
        while(true){
            if(ticket > 0){
                System.out.println(getName()+": 卖票，票号为：" + ticket);
                ticket--;
            } else{
                break;
            }
        }
    }
}
public class WindowTest {
    public static void main(String[] args) {
        Window t1 = new Window();
        Window t2 = new Window();
        Window t3 = new Window();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}


package sq.com.exer;
/**
 * 例子：创建三个窗口卖票，总票数 100 张，使用实现 Runnable 接口的方式
 * 存在线程的安全问题，待解决
 *
 */
class Window1 implements Runnable{

    // 注意 这里没有加 static
    private int ticket = 100;

    @Override
    public void run() {
        while(true){
            if(ticket > 0){
                System.out.println(Thread.currentThread().getName()+": 卖票，票号为: " + ticket);
                ticket--;
            } else{
                break;
            }
        }
    }
}
public class WindowTest1 {
    public static void main(String[] args) {
        Window1 w = new Window1();

        // 传递的是同一个对象，所以变量没有加 static
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}


package com.sq.java;
/**
 * 例子：创建三个窗口卖票，总票数 100 张，使用实现 Runnable 接口的方式
 *
 * 1.问题：卖票过程中，出现了重票、错票 --> 出现了线程的安全问题
 * 2.问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票
 * 3.如何解决：当一个线程 a 在操作 ticket 的时候，其他线程不能参与进来。直到线程 a 操作完 ticket时，其他
 *           线程才可以开始操作 ticket。这种情况即使线程 a 出现了阻塞，也不能被改版。
 * 4.在 Java 中，我们通过同步机制，来解决线程的安全问题
 *
 *      方式一：同步代码块
 *      synchronized(同步监视器){
 *          // 需要被同步的代码
 *
 *      }
 *      说明: 1.操作共享数据的代码，即为需要被同步的代码。--> 不能包含代码多了，也不能包含代码少了。
 *           2.共享数据：多个线程共同操作的变量。比如：ticket 就是共享数据
 *           3.同步监视器，俗称：锁。任何一个类的对象，都可以充当锁
 *              要求：多个线程必须要共用同一把锁
 *
 *          补充：在实现 Runnable 接口创建多线程的方式中，我们可以考虑使用 this 充当同步监视器。
 *
 *      方式二：同步方法
 *          如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。
 *
 * 5.同步的方式，解决了线程的安全问题。--> 好处
 *   操作同步代码时，只能有一个线程参与，其他线程等待，相当于是一个单线程的过程，效率低。 --> 局限性
 *
 *
 */
class Window1 implements Runnable{
    
    private static int ticket = 100;
//    Object obj = new Object();
//    Dog dog = new Dog();
    private static Object obj = new Object();

    @Override
    public void run() {
        // 放在这里就不是公用一把锁了
//        Object obj = new Object();
        while(true){
            synchronized (obj){
                if(ticket > 0){
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+": 卖票，票号为：" + ticket);
                    ticket--;
                } else{
                    break;
                }
            }

        }
    }
}

public class WindowTest1 {
    public static void main(String[] args) {
        Window1 w = new Window1();

        // 传递的是同一个对象，所以变量没有加 static
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}
//class Dog{}


package com.exer;
/**
 * 使用同步代码块解决继承 Thread 类的方式的线程安全问题
 *
 * 例子：创建三个窗口卖票，总票数 100 张，使用实现 Runnable 接口的方式
 *
 * 说明：在继承 Thread 类创建多线程的方式中，慎用 this 充当同步监视器，考虑使用当前类充当充当同步监视器。
 *
 */
class Window2 extends Thread{

    private static int ticket = 100;
    private static Object obj = new Object();

    @Override
    public void run() {
        while(true){
            // 正确的
//            synchronized(obj){
            synchronized(Window2.class){ // Class clazz = Window2.class  Window2.class只会加载一次
            // 错误的方式：this代表着 t1,t2,t3
//          synchronized(this){
                if(ticket > 0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+": 卖票，票号为: " + ticket);
                    ticket--;
                }
            }
        }
    }
}

public class WindowTest2 {
    public static void main(String[] args) {
        Window2 t1 = new Window2();
        Window2 t2 = new Window2();
        Window2 t3 = new Window2();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}


package com.exer;

/**
 * 使用同步方法解决实现 Runnable 接口的线程安全问题
 *  ctrl + alt + l 自动对齐代码
 */
class Window3 implements Runnable {

    private static int ticket = 100;

    @Override
    public void run() {
        while (true) {
            show();
        }
    }
    private synchronized void show(){ // 同步监视器：this
//        synchronized (this){
            if (ticket > 0) {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + ": 卖票，票号为：" + ticket);
                ticket--;
            }
//        }
    }
}

public class WindowTest3 {
    public static void main(String[] args) {
        Window3 w = new Window3();

        // 传递的是同一个对象，所以变量没有加 static
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}


package com.exer;

/**
 * 使用同步方法处理继承 Thread 类的方式中的线程安全问题
 *
 * 关于同步方法的总结：
 * 1.同步方法仍然涉及到同步监视器，只是不需要我们显示的声明。
 * 2.非静态的同步方法，同步监视器是：this
 *   静态的同步方法，同步监视器是：当前类本身
 */
class Window4 extends Thread {

    private static int ticket = 100;

    @Override
    public void run() {
        while (true) {
            show();
        }
    }
    private static synchronized void show(){ // 同步监视器：(静态里不能调this) Window4.class
    // private synchronized void show(){ // 同步监视器：t1，t2，t3。此种解决方式是错误的
        if (ticket > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ": 卖票，票号为: " + ticket);
            ticket--;
        }
    }
}

public class WindowTest4 {
    public static void main(String[] args) {
        Window4 t1 = new Window4();
        Window4 t2 = new Window4();
        Window4 t3 = new Window4();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

package com.exer;

/**
 * 使用同步机制将单例模式中的懒汉式改写为线程安全的
 *
 */
public class BankTest {

}
// 单例模式：懒汉式
class Bank{

    private Bank(){}

    private static Bank instance = null;

    // 解决了线程不安全
//    public static synchronized Bank getInstance(){
    public synchronized Bank getInstance(){

        // 方法一：效率稍差
//        synchronized (Bank.class) {
//            if(instance == null){
//                instance = new Bank();
//            }
//        }
//        return instance;
        // 方式二：效率更高
        if(instance == null){
            synchronized (Bank.class) {
                if(instance == null){
                    instance = new Bank();
                }
            }
        }
        return instance;
    }
}
sunqianLOL
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
3个窗口卖票java_三个窗口同时卖火车票，如何用代码将该场景实现？
weixin_34603814的博客
02-24 2465
今天是我自学Java的第33天。感谢你的陪伴，你的陪伴便是对我最大的鼓励。话不多说，开始今天的学习：线程同步。想必很多小伙伴应该都经历过去火车站买票的情况。现有一个案例：火车站有3个售票窗口，一共有100张票要卖，3个窗口同时卖。对于这种情形，如何使用Java代码来实现？一、多窗口卖票案例根据我们这几天的学习，很显然要创建三个线程来解决这种情况，我们选择使用实现Runnable接口的这种方式来创建...
8-3 sdut-线程-3 利用多线程编程实现多个窗口卖票的问题：三个窗口同时各卖10张票。
TWTyyds的博客
11-30 369
利用多线程编程实现多个窗口卖票的问题：三个窗口同时各卖10张票。
三个窗口同时卖票
dangyongkang的博客
11-30 478
三个窗口同时卖票，这个就涉及到线程安全问题，即多个线程修改同一个变量，以下是我实现的方式 public class SellTicketTest { public static void main(String[] args) { TotalTicket ticket = new TotalTicket(); ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(3, 3, 10, Time
Java 多线程问题 3个窗口卖100张票 不会出现重票和错票
guangtouwj的专栏
04-10 3123
Java多线程的经典案例，3个窗口同时卖100张火车票。要保证没有重复票和错票。 错误案例： public class TestSellTicketsRunnable { public static void main(String[] args) { Tickets tickets = new Tickets(); Thread thread1 ...
【Java基础】多线程实例----三个窗口同时售卖100张车票【详解源码实现】
weixin_46081857的博客
11-16 1万+
本一节作为前一节多线程的补充说明，旨在解决多线程问题中的线程安全问题的解决。 问题描述 假设售票厅有3个窗口可以售卖某次列车的最后100张车票，这三个窗口可以看做三个线程，100张车票可以看做三个线程共享的资源，仔细分析，这个问题中存在线程安全问题。 一.直接实现售票 1.继承Thread类，重run()方法 /** * 三个窗口买票：共售100张票 * 存在线程安全的问题 * @author wds * @date 2021-11-15-20:30 */ public class ThreadT
多线程模拟卖票窗口
02-07
利 用 多 线 程 实 现 模 拟 车 票 售 卖，
Python利用多线程同步锁实现多窗口订票系统(推荐)
12-23
主程序创建了三个窗口线程（window1、window2、window3），然后启动它们。`join()` 方法用于等待所有线程完成，确保主线程不会在子线程之前结束。 **运行结果**： 从输出可以看到，票的销售是按照预期进行的，每个...
Java多线程窗口售票问题实例
08-28
在main()方法中，我们创建了三个线程，分别代表三个窗口，并启动了这些线程。 public class RunnableDemo { public static void main(String[] args) { MyRunnable myRunnable = new MyRunnable(); Thread t1 = ...
07-01 三个售票窗口同时出售20张票（并发）
07-26
这个例子“07-01 三个售票窗口同时出售20张票（并发）”旨在探讨如何在多线程环境下实现并发销售，特别是针对售票系统的场景。在这样的系统中，并发处理能提高效率，但同时也引入了数据一致性的问题。 并发是指多个...
Java实验6多线程.doc
05-02
在Java编程中，多线程是一项重要的特性，它允许程序同时执行多个独立的任务，从而提高程序的并发性和效率。在Java实验6中，学生被要求将一对多的聊天程序改写为多线程的实现，这涉及到Java的并发处理和网络编程。 1...
C语言编写火车售票系统
02-10
链表，文件实现火车票信息的添加删除，分为管理员端与客户端两部分
多线程的应用-----三个窗口卖票问题
qq_45147076的博客
09-22 1537
问题 某电影院目前正在上映国产大片，共有10张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票 应用知识 锁 Lock是控制多个线程对共享资源进行访问的工具。通常，锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。 同步代码块 通过关键字synchronized(任意对象) { 多条语句操作共享数据的代码 } 进行对某段代码块上锁，只有当前锁上的代码执行完毕后，才能继续往下执行。synchronized(任意对象) 的对象，传
多线程实现多个窗口卖票问题
热门推荐
扬帆向海的博客
10-28 1万+
这篇博客解决继承Thread类，线程不共享数据的问题，并且解决了卖票过程中的线程安全问题。
多线程的使用三个窗口同时卖票+线程下载
xia1140418216的博客
07-21 455
1. 两个线程轮流打印数字，一直到100 package XianChengZuoye; public class ZuoYe1 extends Thread{ static int num=0; static Object obj=new Object(); @Override public void run() { while (true){ try { Thread.sleep(2000); synchronized (o
java使用多线程同步方法模拟三个窗口售票
weixin_35754676的博客
12-18 842
在 Java 中，可以使用多线程同步方法来模拟三个窗口售票。 首先，定义一个类表示售票窗口，该类需要有一个共享的计数器表示当前剩余的票数。然后，在该类中定义一个同步方法来执行售票操作，该方法应该检查是否有剩余的票，如果有，则将计数器减 1，并打印出售出一张票的消息。 最后，创建三个线程，分别代表三个售票窗口，并启动这三个线程。 示例代码如下： publicclass TicketWindow ex...
操作系统—基于线程的编程技术
weixin_45823684的博客
03-03 240
Java 操作系统 基于线程的编程操作
创建三个窗口进行卖票 总票100张 使用实现Runnable接口的方法实现
sunyingboaini的博客
03-28 739
例子：创建三个窗口进行卖票 总票100张 使用实现Runnable接口的方法 解决线程安全的问题： 当一个线程在操作ticket的时候，其他线程不能参与进来，直到线程A操作完ticket时候，其他线程才能开始操作，这种情况即使线程A出现了阻塞，也不能被改变 同步代码块:: synchronized（同步监视器）{ 需要同步的代码 } 说明：操作共享数据的代码 就是同步代码 共享数据：多个线程共同操作的变量 如ticket 同步监视器：俗称：锁,任何一个类的对象都可以当做 要求：多个线程，必须共用同一
多线程的实现---＞三个窗口卖票-----两种方式
fengzhengwszz的博客
07-29 1274
package com.atguigu.java; /* * 例子：创建三个窗口卖票，总票数为100张 * * 思想：创建一个窗口类实现买票功能，创建三个对象，实现多线程卖票 * 问题：线程不安全 待解决 * */ //继承的方式 class Window1 extends Thread{ static private int tickets=100;//为了防止每一对象都有100份票，设置为static，则所有对象共享100份票 @Override public void ru
使用多线程完成 三个窗口同时卖票
最新发布
05-17
可以使用 Python 的 threading 模块来实现多线程卖票。下面是一个简单的示例代码： ```python import threading ticket_num = 100 # 总票数 lock = threading.Lock...这样，我们就可以实现三个窗口同时卖票的功能了。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值