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

最新推荐文章于 2022-08-30 09:23:47 发布
最新推荐文章于 2022-08-30 09:23:47 发布
阅读量329 收藏 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
小霖学瓜娃
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java多线程安全问题和锁
01-20
文章目录多线程安全问题和锁线程在jvm中的特点锁的出现synchronized 关键字-监视器锁monitor lock死锁的产生和避免 什么是线程安全问题？ 当多个线程同时操作同一个数据是，可能会出现数据不一样的情况，这就是线程...
java多线程安全性基础介绍.pptx
07-25
java多线程安全性基础介绍 线程安全 正确性 什么是线程安全性 原子性 竞态条件 i++ 读i ++ 值写回i 可见性 JMM 由于cpu和内存加载速度的差距，在两者之间增加了多级缓存导致，内存并不能直接对cpu可见。 ...
Java——线程安全（synchronized解决线程安全问题，窗口售票为例）
挣钱买房买车的博客
08-01 934
Java——线程安全（synchronized解决线程安全问题，窗口售票为例）
Lock锁（卖票案例）
qq_57907966的博客
04-15 327
import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class ylh2 implements Runnable{ private static int tickets = 100; Lock l=new ReentrantLock(); @Override public void run() { whi..
java synchronized 卖票_Java线程同步（synchronized）——卖票问题
weixin_28748867的博客
02-13 231
卖票问题通常被用来举例说明线程同步问题，在Java中，采用关键字synchronized关键字来解决线程同步的问题。Java任意类型的对象都有一个标志位，该标志位具有0，1两种状态，其开始状态为1，当某个线程执行了synchronized(object)语句后，object对象的标志位变为0状态，直到执行完整个synchronized语句中的代码块后，该对象的标志位又回到1状态。当一个线程执行到s...
模拟售票中 synchronized 没有防止超卖问题
white_ice的博客
08-20 1802
       最近在学习 《JAVA多线程编程实战指南》这本书，学到内部锁 synchronized 这里，自己就编写Demo演示模拟售票中超卖的线程安全问题，首先我的代码如下： package com.sailing.thread.entity; import com.sailing.thread.main.ThreadMain; /** * @author Baibing * @p...
通过synchronize的同步代码块线程安全解决火车票超卖问题
窗外的羊
08-17 243
出现问题的原因： 平时自己测试代码需要用到Linux就自己用VMware安装了一个Linux虚拟机，预分配l了18G容量，近期由于安装了很多大数据组件，导致磁盘炸了，所以需要扩容，经过一番搜索和实践之后终于成功扩扩容，记录如下。 过程分析： 总体思路大概是： 1、切换到系统管理员账号； 2、首先保障物理空间的大小，即你的硬盘是可以提供那么大的空间； 3、新建一个目录，用于挂载你的...
线程安全在Java中的应用与实践.pptx.pptx
最新发布
12-18
synchronized关键字是Java提供的一种内建的同步机制，它可以确保同一时刻最多只有一个线程执行该段代码，从而保证线程安全。 volatile关键字 volatile关键字可以保证变量的可见性，当一个线程修改了volatile变量的值...
Java多线程基础——Lock类
08-31
Lock类是Java类来提供的功能，丰富的api使得Lock类的同步功能比synchronized的同步更强大。本文对此进行详细介绍，下面跟着小编一起来看下吧
深入解析Java并发程序中线程的同步与线程锁的使用
09-02
主要介绍了深入解析Java并发编程中线程的同步与线程锁的使用,synchronized和lock是Java中最常见的控制线程的方法,需要的朋友可以参考下
多线程同步解决卖票问题
03-27
多线程同步解决卖票问题
Java 中线程同步机制synchronized，互斥锁，死锁，释放锁的详解
路宇的博客
05-01 1595
一、线程同步机制synchronized的理解 二、synchronized的具体使用 下面可以通过同步机制，解决多线程卖票，出现的超卖问题，代码如下 public class SellTicket { public static void main(String[] args) { // SellTicket01 sellTicket01 = new SellTicket01(); // SellTicket01 sellTicket02 = new SellTick
JUC学习（一）：synchronized的介绍及使用（实现多线程卖票）
m0_49499183的博客
03-20 673
一、synchronized简介 synchronized 是 Java 中的关键字，是一种同步锁。它修饰的对象有以下几种： 1、修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{} 括起来的代码，作用的对象是调用这个代码块的对象；2、修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 3、修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象； ...
分别使用synchronized和lock处理多线程卖票安全问题实例
豆小匠的博客
06-13 1085
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();
分别使用synchronized和Lock实现卖票案例
qq_54658577的博客
11-03 174
1、synchronized （1）创建资源类 public int number代表门票的数量。 public synchronized void sale()；卖票的方法，注意要使用sysnchronized修饰，才是使得这个方法能够自动上锁、自动解锁。 // 创建资源类，定义属性和操作方法 class Ticket{ // 定义票数 public int number = 30; // 方法卖票 public sync...
java 锁实现,Java Synchronized锁和Lock锁实现简单的卖火车票案例
weixin_27960253的博客
03-14 360
Java Synchronized锁和Lock锁实现简单的卖火车票案例发布时间：2018-08-17作者：laosun阅读(2685)Java的线程机制是抢占式的，这表示调度机制会周期性的中断线程，将上下文切换到另一个线程。Java线程的优先级设置setPriority()：线程是通过映射到原生线程上来实现的，所以线程的调度最终还是取决于操作系统，操作系统的优先级于Java的优先级并不一一对应，如...
Synchronized 与 Lock 卖票问题、区别
s17856147699的博客
08-30 122
Synchronized 与 Lock 卖票问题、区别
JUC学习（二）：Lock的介绍及使用（实现多线程卖票）
m0_49499183的博客
03-20 503
一、Lock简介 Lock 锁实现提供了比使用同步方法和语句可以获得的更广泛的锁操作。它们允许更灵活的结构，可能具有非常不同的属性，并且可能支持多个关联的条件对象。Lock 提供了比 synchronized 更多的功能。 Lock 与的 Synchronized 区别： Lock 不是 Java 语言内置的，synchronized 是 Java 语言的关键字，因此是内置特性。Lock 是一个类，通过这个类可以实现同步访问； Lock 和 synchronize...
java---线程安全详解
m0_58196614的博客
08-10 4264
线程安全是指某个方法或某段代码，在多线程中能够正确的执行，不会出现数据不一致或数据污染的情况，我们把这样的程序称之为线程安全的，反之则为非线程安全的。
java线程锁synchronized
11-08
Java中的多线程同步机制主要依靠对象锁机制，synchronized关键字就是利用了封装对象锁来实现对共享资源的互斥访问。当一个线程获取了对象的锁之后，其他线程就不能再访问该对象的synchronized方法或synchronized代码...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值