两种方式实现窗口卖票，同步代码块

已于 2022-04-13 15:20:45 修改
阅读量688 收藏
点赞数 1
文章标签： java 后端 开发语言
于 2022-03-28 12:36:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44530708/article/details/123792191
版权

1.问题:卖票过程中，出现了重票、错票-->出现了线程的安全问题
⒉.问题出现的原因:当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票
3.如何解决:当一个线程a在操作ticket的时候，其他线程不能参与进来。直到线程a操作完ticket时,其他线程才可以开始操作ticket。这种情况即使线程a出现了阻塞，也不能被改变。
4.在Java中，我们通过同步机制，来解决线程的安全问题。

方式一:同步代码块
synchronized(同步监视器){
//需要被同步的代码
}
说明:
1.操作共享数据的代码，即为需要被同步的代码->不能包含多了，也不能包含少了
2.共享数据:多个线程共同操作的变量。比如: ticket就是共享数据。
3.同步监视器，俗称:锁。任何一个类的对象，都可以充当锁。
     要求:多个线程必须要共用同一把锁。
方式二:同步方法
5.同步的方式，解决了线程的安全问题。---好处
操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。---局限性
 

 

 

1、继承Thread类

public class StartApplication
{
    public static void main(String[] args)
    {
        MyThread t1=new MyThread();
        MyThread t2=new MyThread();
        MyThread t3=new MyThread();
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}
class MyThread extends Thread{
    private static int ticket=100;
    @Override
    public void run() {
        while(true){
            if(ticket>0){
                System.out.println(Thread.currentThread().getName()+"卖票，票号为："+ticket);
                ticket--;
            }else{
                break;
            }
        }
    }
}

使用同步代码块

public class StartApplication
{
    public static void main(String[] args)
    {
        MyThread t1=new MyThread();
        MyThread t2=new MyThread();
        MyThread t3=new MyThread();
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}
class MyThread extends Thread{
    private static int ticket=100;
    private static Object obj=new Object();
    @Override
    public void run() {
        while(true) {
            synchronized (obj) {
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "卖票，票号为：" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

或者

public class StartApplication
{
    public static void main(String[] args)
    {
        MyThread t1=new MyThread();
        MyThread t2=new MyThread();
        MyThread t3=new MyThread();
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}
class MyThread extends Thread{
    private static int ticket=100;
    @Override
    public void run() {
        while(true) {
            synchronized (MyThread.class) {
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "卖票，票号为：" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

窗口1卖票，票号为：100
窗口1卖票，票号为：99
窗口1卖票，票号为：98
窗口1卖票，票号为：97
窗口1卖票，票号为：96
窗口1卖票，票号为：95
窗口1卖票，票号为：94
窗口1卖票，票号为：93
窗口1卖票，票号为：92
窗口3卖票，票号为：100
窗口2卖票，票号为：100
窗口2卖票，票号为：89
窗口2卖票，票号为：88
窗口3卖票，票号为：90
窗口3卖票，票号为：86
窗口1卖票，票号为：91
窗口3卖票，票号为：85
窗口2卖票，票号为：87
窗口2卖票，票号为：82
窗口2卖票，票号为：81
窗口2卖票，票号为：80
窗口2卖票，票号为：79
窗口3卖票，票号为：83
窗口3卖票，票号为：77
窗口3卖票，票号为：76
窗口3卖票，票号为：75
窗口3卖票，票号为：74
窗口3卖票，票号为：73
窗口3卖票，票号为：72
窗口3卖票，票号为：71
窗口3卖票，票号为：70
窗口1卖票，票号为：84
窗口3卖票，票号为：69
窗口3卖票，票号为：67
窗口2卖票，票号为：78
窗口3卖票，票号为：66
窗口3卖票，票号为：64
窗口3卖票，票号为：63
窗口3卖票，票号为：62
窗口3卖票，票号为：61
窗口3卖票，票号为：60
窗口3卖票，票号为：59
窗口3卖票，票号为：58
窗口1卖票，票号为：68
窗口3卖票，票号为：57
窗口2卖票，票号为：65
窗口3卖票，票号为：55
窗口1卖票，票号为：56
窗口1卖票，票号为：52
窗口1卖票，票号为：51
窗口1卖票，票号为：50
窗口1卖票，票号为：49
窗口1卖票，票号为：48
窗口3卖票，票号为：53
窗口2卖票，票号为：54
窗口2卖票，票号为：45
窗口2卖票，票号为：44
窗口2卖票，票号为：43
窗口2卖票，票号为：42
窗口2卖票，票号为：41
窗口2卖票，票号为：40
窗口2卖票，票号为：39
窗口2卖票，票号为：38
窗口2卖票，票号为：37
窗口2卖票，票号为：36
窗口2卖票，票号为：35
窗口2卖票，票号为：34
窗口2卖票，票号为：33
窗口3卖票，票号为：46
窗口3卖票，票号为：31
窗口3卖票，票号为：30
窗口3卖票，票号为：29
窗口3卖票，票号为：28
窗口3卖票，票号为：27
窗口3卖票，票号为：26
窗口1卖票，票号为：47
窗口3卖票，票号为：25
窗口3卖票，票号为：23
窗口3卖票，票号为：22
窗口3卖票，票号为：21
窗口3卖票，票号为：20
窗口3卖票，票号为：19
窗口3卖票，票号为：18
窗口3卖票，票号为：17
窗口3卖票，票号为：16
窗口3卖票，票号为：15
窗口3卖票，票号为：14
窗口3卖票，票号为：13
窗口3卖票，票号为：12
窗口3卖票，票号为：11
窗口3卖票，票号为：10
窗口3卖票，票号为：9
窗口3卖票，票号为：8
窗口3卖票，票号为：7
窗口3卖票，票号为：6
窗口3卖票，票号为：5
窗口3卖票，票号为：4
窗口3卖票，票号为：3
窗口3卖票，票号为：2
窗口3卖票，票号为：1
窗口2卖票，票号为：32
窗口1卖票，票号为：24
 

2、实现Runnable接口的方式

public class StartApplication
{
    public static void main(String[] args)
    {
        MThread t=new MThread();
        Thread t1=new Thread(t);
        Thread t2=new Thread(t);
        Thread t3=new Thread(t);
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}
class MThread implements Runnable{
    private int ticket=100;
    @Override
    public void run() {
        while(true){
            if(ticket>0){
                System.out.println(Thread.currentThread().getName()+"卖票，票号为："+ticket);
                ticket--;
            }else{
                break;
            }
        }
    }
}

窗口1卖票，票号为：100
窗口1卖票，票号为：99
窗口1卖票，票号为：98
窗口1卖票，票号为：97
窗口1卖票，票号为：96
窗口1卖票，票号为：95
窗口1卖票，票号为：94
窗口1卖票，票号为：93
窗口1卖票，票号为：92
窗口1卖票，票号为：91
窗口1卖票，票号为：90
窗口1卖票，票号为：89
窗口1卖票，票号为：88
窗口3卖票，票号为：100
窗口2卖票，票号为：100
窗口3卖票，票号为：86
窗口3卖票，票号为：84
窗口3卖票，票号为：83
窗口3卖票，票号为：82
窗口3卖票，票号为：81
窗口3卖票，票号为：80
窗口3卖票，票号为：79
窗口3卖票，票号为：78
窗口3卖票，票号为：77
窗口3卖票，票号为：76
窗口3卖票，票号为：75
窗口3卖票，票号为：74
窗口3卖票，票号为：73
窗口3卖票，票号为：72
窗口3卖票，票号为：71
窗口3卖票，票号为：70
窗口3卖票，票号为：69
窗口3卖票，票号为：68
窗口3卖票，票号为：67
窗口3卖票，票号为：66
窗口3卖票，票号为：65
窗口3卖票，票号为：64
窗口3卖票，票号为：63
窗口3卖票，票号为：62
窗口3卖票，票号为：61
窗口3卖票，票号为：60
窗口3卖票，票号为：59
窗口3卖票，票号为：58
窗口3卖票，票号为：57
窗口3卖票，票号为：56
窗口1卖票，票号为：87
窗口3卖票，票号为：55
窗口3卖票，票号为：53
窗口2卖票，票号为：85
窗口3卖票，票号为：52
窗口1卖票，票号为：54
窗口1卖票，票号为：49
窗口3卖票，票号为：50
窗口3卖票，票号为：47
窗口3卖票，票号为：46
窗口3卖票，票号为：45
窗口3卖票，票号为：44
窗口3卖票，票号为：43
窗口3卖票，票号为：42
窗口3卖票，票号为：41
窗口3卖票，票号为：40
窗口3卖票，票号为：39
窗口3卖票，票号为：38
窗口3卖票，票号为：37
窗口2卖票，票号为：51
窗口2卖票，票号为：35
窗口2卖票，票号为：34
窗口2卖票，票号为：33
窗口2卖票，票号为：32
窗口2卖票，票号为：31
窗口3卖票，票号为：36
窗口3卖票，票号为：29
窗口3卖票，票号为：28
窗口3卖票，票号为：27
窗口3卖票，票号为：26
窗口3卖票，票号为：25
窗口3卖票，票号为：24
窗口3卖票，票号为：23
窗口3卖票，票号为：22
窗口3卖票，票号为：21
窗口3卖票，票号为：20
窗口3卖票，票号为：19
窗口3卖票，票号为：18
窗口3卖票，票号为：17
窗口1卖票，票号为：48
窗口1卖票，票号为：15
窗口3卖票，票号为：16
窗口3卖票，票号为：13
窗口3卖票，票号为：12
窗口3卖票，票号为：11
窗口3卖票，票号为：10
窗口3卖票，票号为：9
窗口3卖票，票号为：8
窗口3卖票，票号为：7
窗口2卖票，票号为：30
窗口2卖票，票号为：5
窗口2卖票，票号为：4
窗口2卖票，票号为：3
窗口2卖票，票号为：2
窗口2卖票，票号为：1
窗口3卖票，票号为：6
窗口1卖票，票号为：14

使用同步部代码块的方式

public class StartApplication
{
    public static void main(String[] args)
    {
        MThread t=new MThread();
        Thread t1=new Thread(t);
        Thread t2=new Thread(t);
        Thread t3=new Thread(t);
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}
class MThread implements Runnable{
    private int ticket=100;
    Object obj=new Object();
    @Override
    public void run() {
        while(true) {
            synchronized (obj) {
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "卖票，票号为：" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

或者

public class StartApplication
{
    public static void main(String[] args)
    {
        MThread t=new MThread();
        Thread t1=new Thread(t);
        Thread t2=new Thread(t);
        Thread t3=new Thread(t);
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}
class MThread implements Runnable{
    private int ticket=100;
    @Override
    public void run() {
        while(true) {
            synchronized (this) {
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "卖票，票号为：" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

窗口3卖票，票号为：100
窗口1卖票，票号为：99
窗口1卖票，票号为：98
窗口1卖票，票号为：97
窗口1卖票，票号为：96
窗口1卖票，票号为：95
窗口1卖票，票号为：94
窗口1卖票，票号为：93
窗口1卖票，票号为：92
窗口1卖票，票号为：91
窗口1卖票，票号为：90
窗口1卖票，票号为：89
窗口1卖票，票号为：88
窗口1卖票，票号为：87
窗口1卖票，票号为：86
窗口1卖票，票号为：85
窗口1卖票，票号为：84
窗口1卖票，票号为：83
窗口1卖票，票号为：82
窗口1卖票，票号为：81
窗口1卖票，票号为：80
窗口1卖票，票号为：79
窗口1卖票，票号为：78
窗口1卖票，票号为：77
窗口1卖票，票号为：76
窗口1卖票，票号为：75
窗口1卖票，票号为：74
窗口1卖票，票号为：73
窗口1卖票，票号为：72
窗口1卖票，票号为：71
窗口1卖票，票号为：70
窗口1卖票，票号为：69
窗口1卖票，票号为：68
窗口1卖票，票号为：67
窗口1卖票，票号为：66
窗口1卖票，票号为：65
窗口1卖票，票号为：64
窗口3卖票，票号为：63
窗口3卖票，票号为：62
窗口3卖票，票号为：61
窗口3卖票，票号为：60
窗口3卖票，票号为：59
窗口3卖票，票号为：58
窗口3卖票，票号为：57
窗口3卖票，票号为：56
窗口3卖票，票号为：55
窗口3卖票，票号为：54
窗口3卖票，票号为：53
窗口1卖票，票号为：52
窗口1卖票，票号为：51
窗口1卖票，票号为：50
窗口1卖票，票号为：49
窗口1卖票，票号为：48
窗口1卖票，票号为：47
窗口1卖票，票号为：46
窗口1卖票，票号为：45
窗口1卖票，票号为：44
窗口1卖票，票号为：43
窗口1卖票，票号为：42
窗口1卖票，票号为：41
窗口1卖票，票号为：40
窗口1卖票，票号为：39
窗口1卖票，票号为：38
窗口1卖票，票号为：37
窗口1卖票，票号为：36
窗口1卖票，票号为：35
窗口1卖票，票号为：34
窗口1卖票，票号为：33
窗口1卖票，票号为：32
窗口1卖票，票号为：31
窗口1卖票，票号为：30
窗口1卖票，票号为：29
窗口1卖票，票号为：28
窗口1卖票，票号为：27
窗口1卖票，票号为：26
窗口1卖票，票号为：25
窗口1卖票，票号为：24
窗口1卖票，票号为：23
窗口1卖票，票号为：22
窗口1卖票，票号为：21
窗口1卖票，票号为：20
窗口1卖票，票号为：19
窗口1卖票，票号为：18
窗口1卖票，票号为：17
窗口1卖票，票号为：16
窗口1卖票，票号为：15
窗口1卖票，票号为：14
窗口1卖票，票号为：13
窗口3卖票，票号为：12
窗口3卖票，票号为：11
窗口3卖票，票号为：10
窗口3卖票，票号为：9
窗口3卖票，票号为：8
窗口3卖票，票号为：7
窗口3卖票，票号为：6
窗口3卖票，票号为：5
窗口3卖票，票号为：4
窗口3卖票，票号为：3
窗口3卖票，票号为：2
窗口3卖票，票号为：1


 

ouxinde
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
多线程使用同步代码块的方式实现两个窗口卖票(不重复)
小白的程序猿
03-05 745
使用两个线程实现两个窗口卖票,不能卖出重复的票,两个线程使用同一个数据 结果图 1.先建立一个共享的数据存储,这里用ArrayList来实现 package com.leiyustudy.thread.safe; import java.util.ArrayList; /** * * */ public class TicketService { private ArrayList...
Java多线程——同步代码块和同步方法
m0_60489526的博客
08-26 1367
一、多线程模拟火车窗口售票 需求：模拟火车票100张，售票窗口 分析： 1.售票窗口使用线程来模拟 2.开4个窗口同时卖100张票 3.4个窗口卖票的任务是一样的 代码演示： // 创建实现类，实现Runnable金额口 public class MyRunnable implements Runnable{ int tickets = 1...
Java＞同步代码块synchronized(){}、同步方法synchronized_method、线程锁Lock ＞ 案例为卖票案例
MySelf_豪
04-18 176
同步代码块synchronized(Object obj){code block} // obj 可以为任意类型的对象，相当于是钥匙 // 使用时，要用obj这个钥匙所对应的锁，锁住需要同步的代码块 synchronized(Object obj){ // 这里是需要同步的代码块 code block } 同步方法synchronized_method public synchronized void method_name(Object obj){ //code_body } 线程锁Lock /
多线程（并发）买票的案例详解同步代码块和同步方法 （复习）
qq_46539281的博客
05-05 1947
文章目录前言简单的原理： 队列+锁常见的买票案例（线程安全：多个线程操作同一个数据。）结果：使用同步代码块或者同步方法（解决线程不安全的问题）添加的方式一：synchronized 关键字结果：分析结果：添加方式二：代码块（注意位置）结果：结果分析：添加方式三：代码块（注意位置）结果：结果分析：添加方式四：代码块（注意位置）结果结果详解每次思考都会有收获。这次记录一下。 前言 复习多线程章节的时候有些疑问，想想后，理解的更深了。由此来记录以下。希望也可以帮助其他的人。 简单的原理： 队列+锁 常.
java 三个窗口同时售卖20张票 ， 解决同步问题 ， 使用三种方式解决同步问题 。同步代码块 、 同步方法 、 同步锁
✈ 正在努力 の 寒江（StudiousTiger) ✌ 呐 ✈
01-21 1249
三个窗口同时售卖20张票 第一种方法使用同步代码块： package foryou.thread.nextStudy; /** * @author : hxhStart * @date : 2021年1月21日下午8:58:39 * @version : */ public class SolveThreadSafe { public static void main(String[] args) { Ticket t1 = new Ticket(); Thread h1 = new Th
两种方式实现窗口卖票，同步方法
weixin_44530708的博客
03-28 547
两种方式实现窗口卖票，同步方法实现
多线程07/例题，多窗口卖票2/解决线程安全问题
Locus的博客
08-03 205
解决线程安全问题 方式一：同步代码块 1，Runnable接口的优化 没解决线程同步问题时，if中写入Thread.sleep(100);可以增加错票几率 synchronized(同步监视器){ 需要被同步的代码 } 说明： 操作共享数据的代码就是需要被同步的代码 共享数据:多个线程共同操作的变量。比如: ticket就是共享数据。 同步监视器，俗称:锁。任何一个类的对象，都可以充当锁。 要求:多个线程必须要共用同一把锁。 class Window1 implements Runnable{
【java基础】线程的生命周期、创建的两种方式及使用、线程的同步
v1xiaolin的博客
11-06 308
目录 一、概念 1、程序、进程、线程 二、线程的创建和使用 1、通过继承Thread类的方式 2、通过实现Runnable接口的方式： 3、Thread类中的相关方法 4、线程优先级 三、线程的生命周期 1、线程的几种状态 四、线程的同步 1、同步代码块 2、同步方法 一、概念 1、程序、进程、线程 程序：是为了完成某个任务，利用某种语言编写的一组指令的集合，及指一块静态的代码。 进程：是程序的一次执行的过程，也可以是一个正在运行的程序，是一个动态的过程，有他自己...
Java中关于解决多线程创建和安全问题的几种方式，通过模拟3个售票窗口卖出100张票的情节
JasomMNn的博客
01-18 713
当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有 执行完，另一个线程参与进来执行。导致共享数据的错误。此时，多线程的安全问题就会出现。 解决办法是对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以 参与执行。 通过模拟3个售票窗口卖出100张票的情节，用代码的方式来实现。 一、多线程的创建 class Window implements Runnable { private int ticket = 100; @Override
Java 编程下的同步代码块(售票员)
qq_37967489的博客
10-27 152
Java 编程下的同步代码块(售票员) 同步代码块比较经典的例子是火车站的售票员售票的过程，下面通过代码来分析同步代码块在这里面的作用。 package cn.sunzn.synchronize; public class SynchronizeCode { public static void main(String[] args) { new TicketSeller().start(); new TicketSeller().start(); new
同步方法解决数据安全问题(案例:卖票)
o676448的博客
04-30 405
同步方法解决数据安全问题一 案例:卖票1 卖票出现的问题:2 问题出现的原因:二 卖票案例的数据安全问题的解决:1. 为什么出现问题?2. 如何解决数据安全问题呢?3. 怎么实现?3. 利用同步代码块实现:5. 同步的好处和弊端?三 用代码写同步代码块 一 案例:卖票 需求:某电影院目前正在上映国产大片,共有100张票,而他有3个窗口卖票,请设计一个程序模拟该电影卖票 (1). 定义一个SellTicket类........................................
Java练习>卖票案例>>解决线性安全问题的方法（使用同步代码块、同步方法、Lock锁）
越努力，越幸福！
08-08 535
卖票案例出现了线性安全问题：卖出了不存在的票和重复的票。 解决线性安全的第一种方案：使用同步代码块。 格式： synchronized(锁对象){ 可能出现线性安全问题的代码(访问了共享数据的代码) } 注意： 同步代码块中的锁对象，可以使用任意的对象 但是必须保证多个线程使用的锁对象是同一个 锁对象作用 把同步代码块锁住，只让一...
线程安全问题之卖票案例（使用同步代码块）
小白学编程
06-17 4375
案例说明：3个窗口同时去卖100张票 实现：需要定义一个卖票的线程，然后在主方法中同时开启3个线程 解决方案：定义一个公共的锁对象，只有得到锁对象才能卖票，执行完毕后释放锁对象 卖票的线程 public class PayTicket implements Runnable{ //定义一个访问的公共资源 private int ticket = 100; Object ...
多线程同步锁模拟售票系统
flyawayl的博客
08-18 1065
使用同步代码块:保证了数据的安全性，因为售票不止一个售票点，多个售票点同时操作同一个数据（卖票）会出现错误。实例：package cn.edu.pzhu;//票务中心 class TicketsCenter { private int tickets; public TicketsCenter(int tickets) { this.tickets = tickets;
卖票功能的实现
sunburstm的博客
11-26 138
package cn.yunhe.xianCheng; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /* 卖票功能 多线程 一个总数 */ public class ZuoYe { public static void main(String[] args) { // TODO Auto-generated method stub Runnable mai = n
卖票小系统（关于线程同步的问题）
趴趴熊的博客
02-07 281
假设有两个窗口合起来要卖100张票，这就涉及到数据共享的问题，故这里用到了线程同步的知识。 [java] view plain copy package xiaojie;      public class Maipiao  {       public static void main(String[] args) {           
Java线程使用之同步机制
weixin_43027596的博客
01-06 165
线程安全问题描述 package atguigu.java; /** * * 例子：创建三个窗口卖票，总票数为100张.使用继承Thread类的方式 * * 由于共享了ticket变量,结果会出现卖重票和错误票的问题,也就是存在线程的安全问题，待解决。 * */ class Window extends Thread{ private static int ticket...
Java之线程安全中的三种同步方式
李章勇的博客
12-12 334
Java之线程安全中的三种同步方式 一个程序在运行起来时，会转换为进程，通常含有多个线程。 通常情况下，一个进程中的比较耗时的操作（如长循环、文件上传下载、网络资源获取等），往往会采用多线程来解决。 比如，现实生活中，银行取钱问题、火车票多个窗口售票问题等，通常会涉及并发问题，从而需要用到多线程技术。 当进程中有多个并发线程进入一个重要数据的代码块...
如何使用synchronized关键字处理线程同步问题？【购票问题】
ty6693的博客
04-15 847
一、问题引入 多个线程实现买票功能： public class MyTickRunnable implements Runnable {//MyTickRunnable实现了Runnable接口 private int tick = 10;//总共剩余10张票 @Override public void run() {//MyTickRunnable覆写了R...
java实现线程同步模拟火车站4个窗口同时卖50张票
最新发布
05-18
下面是一个简单的示例代码，模拟4个窗口同时卖50张票的情况： ```java public class Station implements Runnable { private static int tickets = 50; // 初始票数 private static Object lock = new Object(); ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值