银行存取款模型的线程同步问题

简介: 通过java模拟一个简单的银行存取款模型,阐述对线程同步的理解

  关于线程同步,网上也有很多资料,不过不同的人理解也不大一样,最近在研究这个问题的时候回想起大学课本上的一个经典模型,即银行存取款模型,通过这个模型,我个人感觉解释起来还是比较清楚的。本文结合自己的思考对该模型进行一个简单的模拟,阐述一下我对线程同步的理解。

场景模拟

  接下来使用java对该问题进行模拟。在研究这个问题时会忽略掉现实系统中的很多其他属性,通过一个最简单的余额问题来看线程同步,这里首先创建三个类。

1.卡类,同时卡类提供三个方法,获取余额、存款以及取款。

public class Card {

    /*余额初始化*/
    private double balance;
    public Card(double balance){
        this.balance = balance;
    }

    /*获取余额方法*/
    public double Get_balance(){
        return this.balance;
    }

    /*存款方法*/
    public void deposit(double count) throws InterruptedException{
        System.out.println("存钱线程:存入金额=" + count);
        double now = balance + count;
        balance = now;
        System.out.println("存钱线程:当前金额=" + balance);
    }

    /*取款方法*/
    public void withdraw(double count) throws InterruptedException{
        System.out.println("取钱线程:取出金额=" + count);
        double now = balance - count;
        balance = now;
        System.out.println("取钱线程:当前金额=" + balance);
    }
}

然后是两个线程类,用于模拟并发操作所引入的余额问题。

2.存款线程类,存入金额100。

public class DepositThread extends Thread{
    private Card card;
    public DepositThread(Card card){
        this.card = card;
    }
    @Override
    public void run(){
        try {
            card.deposit(100);
        }
        catch(Exception e){System.out.println(e.toString());}
    }
}

3.取款线程类,取出金额50。

public class WithdrawThread extends Thread{
    private Card card;
    public WithdrawThread(Card card){
        this.card = card;
    }
    @Override
    public void run(){
        try {
            card.withdraw(50);
        }
        catch(Exception e){
            System.out.println(e.toString());
        }
    }
}

  现在先进行一个测试,让存款线程先进行存钱操作,然后取款线程进行取款,最后验证余额与逻辑是否符合。

测试代码如下:

public class CardTest{
    public static void main(String[] args) throws InterruptedException{
        Card card = new Card(100);
        System.out.println("操作前余额:" + card.Get_balance());
        DepositThread depositThread = new DepositThread(card);
        WithdrawThread withdrawThread = new WithdrawThread(card);
        depositThread.start();
        withdrawThread.start();
        Thread.sleep(2000);
        System.out.println("最终余额:" + card.Get_balance());
    }
}

运行后输出如下结果:
result1

  现在大致的看一下,初始余额为100,然后存款线程存入100,接下来取款线程取走50,那么最后余额为150。这么看来,貌似没问题?

数据不一致问题

  事实上,存取款过程是需要消耗时间的,只要一个线程在操作余额期间受到其他线程的干扰,就可能出现数据不一致问题。这里我们修改存取款方法的代码如下。

存款方法:

    public void deposit(double count) throws InterruptedException{
        System.out.println("存钱线程:存入金额=" + count);
        double now = balance + count;
        Thread.sleep(100);    //存钱的操作用时0.1s
        balance = now;
        System.out.println("存钱线程:当前金额=" + balance);
    }

取款方法:

    public void withdraw(double count) throws InterruptedException{
        System.out.println("取钱线程:取出金额=" + count);
        double now = balance - count;
        Thread.sleep(200);    //取钱的操作用时0.2s
        balance = now;
        System.out.println("取钱线程:当前金额=" + balance);
    }
}

然后再运行一遍测试程序:
result2

  现在,我们发现最终余额变成了50,这很显然是个完全不符合预期的错误结果。那么,如何来解释这个现象呢?
lock1
  从上图可以看到,出现数据不一致的原因在于多个线程并发访问了同一个对象,破坏了不可分割的操作,这里的这个共同访问对象就是余额。其实我们所谓预期的‘正确’结果,就是希望先进行存款,然后再进行取款,或者反之。

原子操作与锁

  上面提到‘不可分割的操作’,这种操作就是原子操作。是因为实际上多线程编程的情境下,很多敏感数据不允许被同时访问,因此对于这种针对敏感数据的操作,需要进行线程访问的协调与控制,这就是所谓的线程同步(协同步调)访问技术。线程同步控制的结果,就是把每次对敏感数据的操作变成原子操作,从而让执行顺序按照我们预期的过程进行。
  上述情境下,存款与取款应当是两个原子操作,我们必须保证先进行且完成存款操作再进行取款操作,才能保证最终数据的一致性,才能得到我们认为是‘正确’的结果。

下面我们通过锁来实现线程同步访问控制,修改Card类的代码如下。

public class Card {

    private double balance;
    private Object lock = new Object(); //锁

...省略其它代码

    /*存款*/
    public void deposit(double count) throws InterruptedException{
        System.out.println("存钱线程:存入金额=" + count);
        synchronized (lock) {
            double now = balance + count;
            Thread.sleep(100);//存钱的操作用时0.1s
            balance = now;
        }
        System.out.println("存钱线程:当前金额=" + balance);
    }

    /*取款*/
    public void withdraw(double count) throws InterruptedException{
        System.out.println("取钱线程:取出金额=" + count);
        synchronized (lock) {
            double now = balance - count;
            Thread.sleep(200);//取钱的操作用时0.2s
            balance = now;
        }
        System.out.println("取钱线程:当前金额=" + balance);
    }
}

运行结果如下:
result3

  这段代码中,通过synchronized 关键字保证lock对象只能同时被一个线程访问,要想操作余额,那么必须先获取lock对象的访问许可,因此就保证了余额不会被多个线程同时修改,而最终的结果也完全符合我们的预期。这个lock对象就可以形象的理解成锁,整个执行过程大致如下图所示,
lock2

目录
相关文章
|
1月前
|
Java
网络 I/O:单 Selector 多线程(单线程模型)
网络 I/O:单 Selector 多线程(单线程模型)
|
1月前
|
人工智能 JSON 前端开发
【Spring boot实战】Springboot+对话ai模型整体框架+高并发线程机制处理优化+提示词工程效果展示(按照框架自己修改可对接市面上百分之99的模型)
【Spring boot实战】Springboot+对话ai模型整体框架+高并发线程机制处理优化+提示词工程效果展示(按照框架自己修改可对接市面上百分之99的模型)
|
24天前
|
存储 安全 Java
Qt线程池+生产者消费者模型
Qt线程池+生产者消费者模型
48 5
|
18天前
|
消息中间件 监控 Java
滴滴面试:谈谈你对Netty线程模型的理解?
Netty 线程模型是指 Netty 框架为了提供高性能、高并发的网络通信,而设计的管理和利用线程的策略和机制。 **Netty 线程模型被称为 Reactor(响应式)模型/模式,它是基于 NIO 多路复用模型的一种升级,它的核心思想是将 IO 事件和业务处理进行分离,使用一个或多个线程来执行任务的一种机制。** ## 1.**Reactor三大组件** Reactor 包含以下三大组件: ![image.png](https://cdn.nlark.com/yuque/0/2024/png/92791/1717079218890-89000a00-48bc-4a1a-b87e-e1b6
26 2
|
20天前
|
安全 调度
鸿蒙HarmonyOS实战-Stage模型(线程模型)
本文介绍了线程作为操作系统调度的最小单位,是进程中的执行流,具有轻量级、并发执行、共享资源、通信简单和上下文切换等特点。线程分为用户线程和内核线程,其中内核线程由操作系统管理,而用户线程由应用程序控制。线程用于提高程序性能和响应速度,尤其适合多任务并发处理。在HarmonyOS中,每个应用有主线程负责UI和 ArkTS 引擎管理,以及Worker线程执行耗时任务。线程间通信可通过Emitter实现事件同步和Worker进行异步操作。
|
21天前
|
设计模式 安全 Java
多线程(代码案例: 单例模式, 阻塞队列, 生产者消费者模型,定时器)
多线程(代码案例: 单例模式, 阻塞队列, 生产者消费者模型,定时器)
24 2
|
25天前
|
NoSQL 网络协议 关系型数据库
redis-学习笔记(redis 单线程模型)
redis-学习笔记(redis 单线程模型)
28 3
|
25天前
|
Linux 调度 Windows
【操作系统】线程、多线程模型
【操作系统】线程、多线程模型
31 1
|
26天前
|
NoSQL 关系型数据库 MySQL
Redis -- 单线程模型
Redis -- 单线程模型
38 1
|
27天前
|
设计模式 安全 Java
【Linux 系统】多线程(生产者消费者模型、线程池、STL+智能指针与线程安全、读者写者问题)-- 详解
【Linux 系统】多线程(生产者消费者模型、线程池、STL+智能指针与线程安全、读者写者问题)-- 详解