Java线程安全(卖票案例) 如何解决线程安全（synchronized ，显示锁Lock）

最新推荐文章于 2022-02-22 16:59:53 发布
最新推荐文章于 2022-02-22 16:59:53 发布
阅读量353 收藏 2
点赞数 1
文章标签： java 多线程 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_47422889/article/details/119520773
版权

文章目录

线程安全

经典问题：卖票问题，多个线程一起执行该任务，当余票只有1一张时，三个线程都进入了卖票，这时就会发生错误。导致了余票<0 的问题

public class ThreadDemo1 {
    public static void main(String[] args) throws InterruptedException {
        // 线程安全问题
        Runnable r = new MyRunnable();
        Thread t1 = new Thread(r);
        Thread t2 = new Thread(r);
        Thread t3 = new Thread(r);
        t1.start();
        t2.start();
        t3.start();
    }
}
class MyRunnable implements Runnable{
    // 票数
    private int ticket = 10;
    @Override
    public void run() {
        // 卖票
        while(ticket > 0){
            System.out.println(Thread.currentThread().getName()+"正在准备卖票");
            try {
                Thread.sleep(1000); //让发生问题的错误几率加大
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            ticket--;
            System.out.println(Thread.currentThread().getName()+"出票成功，余票：" + ticket);
        }
    }
}

运行结果：卖票出现了错误

Thread-0正在准备卖票
Thread-1正在准备卖票
Thread-2正在准备卖票
Thread-2出票成功，余票：8
Thread-2正在准备卖票
Thread-1出票成功，余票：8
Thread-1正在准备卖票
Thread-0出票成功，余票：8
Thread-0正在准备卖票
Thread-1出票成功，余票：7
Thread-0出票成功，余票：7
Thread-0正在准备卖票
Thread-2出票成功，余票：6
Thread-2正在准备卖票
Thread-1正在准备卖票
Thread-0出票成功，余票：4
Thread-2出票成功，余票：3
Thread-2正在准备卖票
Thread-1出票成功，余票：5
Thread-1正在准备卖票
Thread-0正在准备卖票
Thread-0出票成功，余票：2
Thread-0正在准备卖票
Thread-1出票成功，余票：2
Thread-1正在准备卖票
Thread-2出票成功，余票：2
Thread-2正在准备卖票
Thread-2出票成功，余票：1
Thread-1出票成功，余票：0
Thread-0出票成功，余票：-1

解决方法：

1、同步代码块

使用synchronized 关键字 （隐式锁）

格式：

synchronized (锁对象){ //这里的锁对象必须的同一个锁对象
    // 同步执行的代码块
}

public class ThreadDemo1 {
    public static void main(String[] args) throws InterruptedException {
        // 线程安全问题
        Runnable r = new MyRunnable();
        Thread t1 = new Thread(r);
        Thread t2 = new Thread(r);
        Thread t3 = new Thread(r);
        t1.start();
        t2.start();
        t3.start();
    }
}
class MyRunnable implements Runnable{
    // 票数
    private int ticket = 10;
    private Object o = new Object();
    @Override
    public void run() {
        // 卖票
        while(true){
            synchronized(o) { // 锁对象 - 任意对象都行，但必须是同一个对象
                // 里边是同步代码块
                if (ticket > 0){
                    System.out.println(Thread.currentThread().getName()+"正在准备卖票");
                    try {
                        Thread.sleep(1000); //让发生问题的错误几率加大
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    ticket--;
                    System.out.println(Thread.currentThread().getName()+"出票成功，余票：" + ticket);

                } else {
                    break;
                }
            }
        }
    }
}

结果：

Thread-0正在准备卖票
Thread-0出票成功，余票：9
Thread-0正在准备卖票
Thread-0出票成功，余票：8
Thread-0正在准备卖票
Thread-0出票成功，余票：7
Thread-2正在准备卖票
Thread-2出票成功，余票：6
Thread-2正在准备卖票
Thread-2出票成功，余票：5
Thread-1正在准备卖票
Thread-1出票成功，余票：4
Thread-1正在准备卖票
Thread-1出票成功，余票：3
Thread-1正在准备卖票
Thread-1出票成功，余票：2
Thread-1正在准备卖票
Thread-1出票成功，余票：1
Thread-1正在准备卖票
Thread-1出票成功，余票：0

2、同步方法

就是在方法加上synchronized

锁对象：方法的this，如果是静态的方法，就是类名.class 如：MyRunnable.class

public class ThreadDemo1 {
    public static void main(String[] args) throws InterruptedException {
        // 线程安全问题
        Runnable r = new MyRunnable();
        Thread t1 = new Thread(r);
        Thread t2 = new Thread(r);
        Thread t3 = new Thread(r);
        t1.start();
        t2.start();
        t3.start();
    }
}
class MyRunnable implements Runnable{
    // 票数
    private int ticket = 10;
    private Object o = new Object();
    @Override
    public void run() {
        // 卖票
        while(true){
            if (!sale()) break;
        }
    }
    //卖票方法
    public synchronized boolean sale(){
        if (ticket > 0){
            System.out.println(Thread.currentThread().getName()+"正在准备卖票");
            try {
                Thread.sleep(1000); //让发生问题的错误几率加大
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            ticket--;
            System.out.println(Thread.currentThread().getName()+"出票成功，余票：" + ticket);
            return true;
        } else {
            return false;
        }
    }
}

结果：

Thread-0正在准备卖票
Thread-0出票成功，余票：9
Thread-0正在准备卖票
Thread-0出票成功，余票：8
Thread-0正在准备卖票
Thread-0出票成功，余票：7
Thread-0正在准备卖票
Thread-0出票成功，余票：6
Thread-0正在准备卖票
Thread-0出票成功，余票：5
Thread-0正在准备卖票
Thread-0出票成功，余票：4
Thread-2正在准备卖票
Thread-2出票成功，余票：3
Thread-1正在准备卖票
Thread-1出票成功，余票：2
Thread-1正在准备卖票
Thread-1出票成功，余票：1
Thread-1正在准备卖票
Thread-1出票成功，余票：0

Process finished with exit code 0

3、显示锁

public class ThreadDemo1 {
    public static void main(String[] args) throws InterruptedException {
        // 线程安全问题
        Runnable r = new MyRunnable();
        Thread t1 = new Thread(r);
        Thread t2 = new Thread(r);
        Thread t3 = new Thread(r);
        t1.start();
        t2.start();
        t3.start();
    }
}
class MyRunnable implements Runnable{
    // 票数
    private int ticket = 10;
    // 显示锁 lock
    private Lock lock = new ReentrantLock();
    @Override
    public void run() {
        // 卖票
        while(true){
            // 上锁
            lock.lock();
            if (ticket > 0){
                System.out.println(Thread.currentThread().getName()+"正在准备卖票");
                try {
                    Thread.sleep(1000); //让发生问题的错误几率加大
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                ticket--;
                System.out.println(Thread.currentThread().getName()+"出票成功，余票：" + ticket);
            } else {
                break;
            }
            // 解锁
            lock.unlock();
        }
    }
}

显示锁与隐式锁的区别

所谓的显示和隐式就是在使用的时候，使用者要不要手动写代码去获取锁和释放锁的操作。

我们大家都知道，在使用sync关键字的时候，我们使用者根本不用写其他的代码，然后程序就能够获取锁和释放锁了。那是因为当sync代码块执行完成之后，系统会自动的让程序释放占用的锁。Sync是由系统维护的，如果非逻辑问题的话话，是不会出现死锁的。

在使用lock的时候，我们使用者需要手动的获取和释放锁。如果没有释放锁，就有可能导致出现死锁的现象。手动获取锁方法：lock.lock()。释放锁：unlock方法。需要配合tyr/finaly语句块来完成

4、公平锁与非公平锁

公平锁：先来先用

非公平锁：大家一块抢

以上三种都是非公平锁~

公平锁定义：

private Lock lock = new ReentrantLock(true);

指定 true 就是公平锁，

public class ThreadDemo1 {
    public static void main(String[] args) throws InterruptedException {
        // 线程安全问题
        Runnable r = new MyRunnable();
        Thread t1 = new Thread(r);
        Thread t2 = new Thread(r);
        Thread t3 = new Thread(r);
        t1.start();
        t2.start();
        t3.start();
    }
}
class MyRunnable implements Runnable{
    // 票数
    private int ticket = 10;
    // 显示锁 lock --公平锁
    private Lock lock = new ReentrantLock(true);
    @Override
    public void run() {
        // 卖票
        while(true){
            // 上锁
            lock.lock();
            if (ticket > 0){
                System.out.println(Thread.currentThread().getName()+"正在准备卖票");
                try {
                    Thread.sleep(1000); //让发生问题的错误几率加大
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                ticket--;
                System.out.println(Thread.currentThread().getName()+"出票成功，余票：" + ticket);
            } else {
                break;
            }
            // 解锁
            lock.unlock();
        }
    }
}

结果：（线程0，线程1，线程2有序执行）

Thread-0正在准备卖票
Thread-0出票成功，余票：9
Thread-1正在准备卖票
Thread-1出票成功，余票：8
Thread-2正在准备卖票
Thread-2出票成功，余票：7
Thread-0正在准备卖票
Thread-0出票成功，余票：6
Thread-1正在准备卖票
Thread-1出票成功，余票：5
Thread-2正在准备卖票
Thread-2出票成功，余票：4
Thread-0正在准备卖票
Thread-0出票成功，余票：3
Thread-1正在准备卖票
Thread-1出票成功，余票：2
Thread-2正在准备卖票
Thread-2出票成功，余票：1
Thread-0正在准备卖票
Thread-0出票成功，余票：0
小霖学瓜娃
关注
Java多线程06—用Lock锁解决线程的安全问题
小贺想改变
10-06 819
解决线程安全问题的方式三：Lock锁、一道经典练习题
Java 学习 多线程 线程安全 售票员卖票问题
NaiYeZou的博客
04-01 471
public class Seller extends Thread{ public static Integer ticket = 10; private String sellername; public Seller(String sellername) { super(); this.sellername = sellername; } @Override public void run() { while (ticket > 0) { try { .
Java学习之线程安全详解（卖票案例）
RookieThree的博客
05-25 575
一、要求，有100张票，要求同时在三个窗口出售 首先创建卖票的类： package com.edu_03; public class ShellTicket implements Runnable{ int tickets = 100; @Override public void run() { while (true) {//让窗口一直处于打开的状态 if (ticke
Java 多线程 卖票案例数据安全问题的解决
weixin_46441425的博客
02-22 203
Java 多线程卖票1 线程安全问题
柚咖小窝
03-28 318
题目要求：使用三个线程卖 100 张票 继承 Thread 类创建线程 子类 Window1 的代码： class Window1 extends Thread { private static int ticket = 100;// 目前还有 ticket 张票 @Override public void run() { while (true) { if (ticket > 0) { // 如果还有票 System.out.println(Thread.curren
java实现多线程（车站卖票）
热门推荐
南 墙
07-30 1万+
import java.util.ArrayList; import java.util.List; public class 多线程 { // public static int j=0; public static long a=0; public static void main(String[] args) throws InterruptedException { List&l...
Java线程同步（synchronized）——卖票问题
aptrsh7390的博客
06-16 353
　　卖票问题通常被用来举例说明线程同步问题，在Java中，采用关键字synchronized关键字来解决线程同步的问题。 　　Java任意类型的对象都有一个标志位，该标志位具有0，1两种状态，其开始状态为1，当某个线程执行了synchronized(object)语句后，object对象的标志位变为0状态，直到执行完整个synchronized语句中的代码块后，该对象的标志位又回到1状...
Java多线程-避免同步机制带来的死锁问题及用Lock锁解决线程安全问题
最新发布
02-02
### Java多线程-避免同步机制带来的死锁问题及用Lock锁解决线程安全问题 #### 死锁 ##### 1. 说明 在多线程编程中，死锁是一种常见的问题，指的是两个或多个线程在执行过程中，因为竞争资源而造成的一种相互等待...
Java多线程安全问题和锁
01-20
文章目录多线程安全问题和锁线程在jvm中的特点锁的出现synchronized 关键字-监视器锁monitor lock死锁的产生和避免 什么是线程安全问题？ 当多个线程同时操作同一个数据是，可能会出现数据不一样的情况，这就是线程...
Java线程安全.docx
10-24
解决这个问题，可以使用synchronized关键字或Lock接口来确保线程安全地访问和修改共享资源。例如： ```java public class Account { private int balance; public Account(int balance) { this.balance = ...
Java实现根据卖票案例分析线程安全原理以及解决线程安全的三种方法
派拉斯兔子的博客
07-20 568
如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。 我们通过一个案例，演示线程的安全问题： 电影院要卖票，我们模拟电影院的卖票过程。假设要播放的电影是 “葫芦娃大战奥特曼”，本次电影的座位共100个(本场电影只能卖100张票)。
Java 线程安全
m0_37981386的博客
10-18 101
1、 同步代码块 synchronized(任意对象) { 多条语句操作共享数据的代码 } synchronized(任意对象)：就相当于给代码加锁了，任意对象就可以看成是一把锁 package com.itheima_08; public class SellTicket implements Runnable { private int tickets = 100; private Object obj = new Object...
Java使用多线程模拟车站售票（ 使用synchronized 方法保证线程同步）
q1372302825的博客
12-04 1337
Java使用多线程模拟售票 实现代码： ​ package com.fan.base; import lombok.Getter; import lombok.Setter; import java.util.Stack; /** * 多线程同步方法测试 */ public class MultipleThreadSellTicketSynchronizingDemo { public static void main(String[] args) { SellTick
分别使用synchronized和Lock实现卖票案例
qq_54658577的博客
11-03 221
1、synchronized （1）创建资源类 public int number代表门票的数量。 public synchronized void sale()；卖票的方法，注意要使用sysnchronized修饰，才是使得这个方法能够自动上锁、自动解锁。 // 创建资源类，定义属性和操作方法 class Ticket{ // 定义票数 public int number = 30; // 方法卖票 public sync...
分别使用synchronized和lock处理多线程卖票安全问题实例
豆小匠的博客
06-13 1118
1、使用synchronized public class SaleTicketDemo { public static void main(String[] args) { // 多个售票员售票 Ticket ticket = new Ticket(); new Thread(() -> { for (int i = 0; i < 40; i++) { ticket.sale();
卖票线程安全版
m0_52936310的博客
01-31 113
卖票线程安全版 package src.main.java.com.qqjx.thread; /** * 有N张火车票，每张票都有一个编号 * 同时有10个窗口对外售票 * 请写一个模拟程序 * * 分析下面的程序可能会产生哪些问题？ * 重复销售？超量销售？ * * 使用Vector或者Collections.synchronizedXXX * 分析一下，这样能解决问题吗？ * * 就算操作A和B都是同步的，但A和B组成的复合操作也未必是同步的，仍然需要...
java synchronized 卖票_java多线程实现卖票程序（synchronized）
weixin_39623620的博客
02-13 284
本文采用java多线程实现了模拟车站多个车票卖票的功能。关键词：java多线程 并发 共享资源 互斥访问 实现runnable接口 volatile 线程同步。关键：线程同步，因为创建了多个线程，那么卖票部分代码应该上锁来保证线程对此关键代码的互斥访问，上锁的方式有两种，一种是synchronized隐式锁，另一种是Lock.lock()显式锁。问题1：两种锁的区别:使用显示锁可以做到更细的控制...
java线程安全问题--"卖票问题"
duanyaowei的博客
04-18 470
当java程序启动至少有几个线程产生？ 当java程序从main方法开始执行时，就会伴随着一个线程的产生，程序结束后也会伴随着线程回收机制的开启，也会有有一个线程产生。所以在java程序开始执行时，至少有两个线程。 程序的设计是这样的：模拟电影院卖票问题，假如一家电影院正在上映唐人街探案6，假设一个电影院只有100张票，分四个窗口来售票。接下来我把代码和问题展示给大家。 我们期望的是运行结果应...
Java多线程卖票案例：理解线程安全与同步策略
在模拟的卖票案例中，`RunnableImpl` 类中的 `ticket` 变量被多个线程共享，每个线程都在无限循环中尝试卖票。如果多个线程同时检测到票数量大于0，它们会尝试减少票数，这可能导致数据不一致。例如，一个线程可能...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值