多线程三种同步方式（模拟银行取款）

最新推荐文章于 2021-10-14 23:57:29 发布
最新推荐文章于 2021-10-14 23:57:29 发布
阅读量2.2k 收藏 26
点赞数 2
分类专栏： Java基础 文章标签： 多线程 java 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53609683/article/details/117661721
版权

方法一：同步代码块

Accoun

package com.bjsxt.synch1;

/**
 * 银行账户类
 */
public class Account {
    private int balance = 600;//余额

    /**
     * 取款
     * @param money
     */
    public void withDraw(int money){
        this.balance = this.balance -money;
    }

    /**
     * 查看余额
     * @return
     */
    public int getBalance(){
        return balance;
    }
}

取款线程

package com.bjsxt.synch1;

/**
 * 取款的线程
 *
 * 线程同步方式1：同步代码块
 *
 * 总结1：认识同步监视器（锁子）
 *     synchronized(同步监视器){ }
 * 1)必须是引用数据类型，不能是基本数据类型
 * 2)在同步代码块中可以改变同步监视器对象的值，不能改变其引用
 * 3)尽量不要String和包装类Integer做同步监视器.如果使用了，只要保证代码块中不对其进行任何操作也没有关系
 * 4)一般使用共享资源做同步监视器即可
 * 5)也可以创建一个专门的同步监视器，没有任何业务含义
 * 6)建议使用final修饰同步监视器
 *
 * 总结2：同步代码块的执行过程
 * 1)第一个线程来到同步代码块，发现同步监视器open状态，需要close,然后执行其中的代码
 * 2)第一个线程执行过程中，发生了线程切换（阻塞 就绪），第一个线程失去了cpu，但是没有开锁open
 * 3)第二个线程获取了cpu，来到了同步代码块，发现同步监视器close状态，无法执行其中的代码，第二个线程也进入阻塞状态
 * 4)第一个线程再次获取CPU,接着执行后续的代码；同步代码块执行完毕，释放锁open
 * 5)第二个线程也再次获取cpu，来到了同步代码块，发现同步监视器open状态，重复第一个线程的处理过程（加锁）
 * 强调：同步代码块中能发生线程切换吗？能！！！ 但是后续的被执行的线程也无法执行同步代码块（锁仍旧close）

 * 总结3：线程同步 优点和缺点
 *     优点：安全
 *     缺点：效率低下  可能出现死锁
 *    
 * 总结4：其他
 * 1)多个代码块使用了同一个同步监视器（锁），锁住一个代码块的同时，也锁住所有使用该锁的所有代码块，其他线程无法访问其中的任何一个代码块
 * 2)多个代码块使用了同一个同步监视器（锁），锁住一个代码块的同时，也锁住所有使用该锁的所有代码块， 但是没有锁住使用其他同步监视器的代码块，其他线程有机会访问其他同步监视器的代码块

 */
public class AccountRunnable implements  Runnable{
    private final  Account account = new Account();
    final Object obj = new Object();
    //byte [] buf = new byte[1];
    //final String str = "bjsxt";
    //final Integer in = 1234;

    //int n = 5;
    /**
     * 线程体：取款的步骤
     */
    @Override
    public void run() {
        //此处省略200句
 
        synchronized (account){
            if(account.getBalance()>=400){//余额足够  临界代码
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //就取款
                account.withDraw(400);
                System.out.println(Thread.currentThread().getName()+"取款成功,当前余额："+account.getBalance());

            }else{//余额不足
                //给出提示
                System.out.println(Thread.currentThread().getName()+"取款失败,余额不足，当前余额："+account.getBalance());
            }
        }

        //此处省略100句
    }

    public void method1(){
        synchronized (account){

        }


    }

    public void method2(){

        synchronized (obj){

        }


    }

    public void method3(){
        synchronized (obj){

        }


    }
}

main

package com.bjsxt.synch1;

public class TestAccount {
    public static void main(String[] args) {
        //创建两个线程，模拟两个用户
        Runnable runnable = new AccountRunnable();
        Thread thread1 = new Thread(runnable,"张三");
        Thread thread2 = new Thread(runnable,"张三妻子");

        //启动两个线程，模拟两个用户取款
        thread1.start();
        thread2.start();
    }
}

方法二：同步方法

银行账户类

package com.bjsxt.synch2;

/**
 * 银行账户类
 */
public class Account {
    private int balance = 600;//余额

    /**
     * 取款
     * @param money
     */
    public void withDraw(int money){
        this.balance = this.balance -money;
    }

    /**
     * 查看余额
     * @return
     */
    public int getBalance(){
        return balance;
    }
}

取款的线程

package com.bjsxt.synch2;

/**
 * 取款的线程
 *方式2：同步方法
 *
 * 1.不要给run()加锁
 * 2. 非静态同步方法的锁：this
 *    静态同步方法的锁：类名.class
 * 3.同步方法和同步代码块哪种效率高
 *    同步代码块效率高
 *
 */
public class AccountRunnable implements  Runnable{
    private Account account = new Account();
    /**
     * 线程体：取款的步骤
     */
    @Override
    public  void run() {
        //此处省略200句

        //取款
        withDraw();

        //此处省略100句
    }

    public synchronized void withDraw(){      //非静态同步方法的锁是this
        if(account.getBalance()>=400){       //余额足够  临界代码
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //就取款
            account.withDraw(400);
            System.out.println(Thread.currentThread().getName()+"取款成功,当前余额："+account.getBalance());

        }else{//余额不足
            //给出提示
            System.out.println(Thread.currentThread().getName()+"取款失败,余额不足，当前余额："+account.getBalance());
        }
    }

    public synchronized  void method1(){ //this

    }
    public synchronized  void method2(){ //this
        // Vector v;
    }

    public synchronized  static void method3(){ //静态的同步方法的锁是类名.class 类对象 AccountRunnable.class
        //Class clazz =  AccountRunnable.class;
    }

    public synchronized static void method4(){

    }
}

main

package com.bjsxt.synch2;

public class TestAccount {
    public static void main(String[] args) {
        //创建两个线程，模拟两个用户
        Runnable runnable = new AccountRunnable();
        Thread thread1 = new Thread(runnable,"张三");
        Thread thread2 = new Thread(runnable,"张三妻子");

        //启动两个线程，模拟两个用户取款
        thread1.start();
        thread2.start();
    }
}

方法三：锁

银行账户类

package com.bjsxt.synch3;

/**
 * 银行账户类
 */
public class Account {
    private int balance = 600;//余额

    /**
     * 取款
     * @param money
     */
    public void withDraw(int money){
        this.balance = this.balance -money;
    }

    /**
     * 查看余额
     * @return
     */
    public int getBalance(){
        return balance;
    }
}

取款的线程

package com.bjsxt.synch3;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 取款的线程
 */
public class AccountRunnable implements  Runnable{
    private Account account = new Account();

    //购买一把锁
    private Lock lock = new ReentrantLock();//Re-entrant-Lock  //entrance 可重入锁
    /**
     * 线程体：取款的步骤
     */
    @Override
    public void run() {
        //此处省略200句

        //上锁
        lock.lock();
        try{
            if(account.getBalance()>=400){//余额足够  临界代码
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //就取款
                account.withDraw(400);
                System.out.println(Thread.currentThread().getName()+"取款成功,当前余额："+account.getBalance());

            }else{//余额不足
                //给出提示
                System.out.println(Thread.currentThread().getName()+"取款失败,余额不足，当前余额："+account.getBalance());
            }
            method1();
        }finally{
            //解锁
            lock.unlock();
        }




        //此处省略100句
    }

    public void method1(){

        lock.lock();
        try{
            method2();
        }finally{
            lock.unlock();
        }


    }

    public void method2(){
        lock.lock();
        try{

        }finally{
            lock.unlock();
        }
    }
}

main

package com.bjsxt.synch3;

public class TestAccount {
    public static void main(String[] args) {
        //创建两个线程，模拟两个用户
        Runnable runnable = new AccountRunnable();
        Thread thread1 = new Thread(runnable,"张三");
        Thread thread2 = new Thread(runnable,"张三妻子");

        //启动两个线程，模拟两个用户取款
        thread1.start();
        thread2.start();
    }
}
AloneDrifters
关注
  • 2
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java多线程——模拟银行存取钱功能-实验四
m0_52709447的博客
05-26 1277
在银行办理业务时，通常银行会开多个窗口，客户排队等候，窗口办理完业务，会呼叫下一个用户办理业务。假如有两个用户在存取钱，两个用户分别操作各自的账户，并在控制台打印存取钱的数量以及账户的余额。线程锁判断是哪一位用户，在存钱和取钱的方法中先调用获取当前用户方法判断操作者，再进行存取钱操作，需要注意的是在进行取钱操作时，需要判断余额是否大于需要取的钱数。在银行类中需要定义一个账户的实体类、一个存钱的方法、一个取钱的方法、查询余额的方法和获取当前用户的方法。循环调用线程模拟用户存取钱操作。接口的方法来创建线程。
以银行取钱为例模拟Java多线程同步问题完整代码
08-28
主要介绍了以银行取钱为例模拟Java多线程同步问题完整代码，具有一定借鉴价值，需要的朋友可以参考下。
#JAVA多线程程序——“模拟银行”
ybtxts的博客
12-16 1398
JAVA多线程程序——“模拟银行”“模拟银行”作业，多线程，除主线程外 设有CustomerGenerator线程：负责源源不断随机生成办理业务的顾客，顾客的操作类型、金额、业务时间都是随机 Teller线程：负责从等待顾客队列中抽取第一个顾客，办理业务 import java.util.Random; import java.util.concurrent.TimeUnit; im
多线程学习（四）——线程同步之同步代码块和同步方法（银行取钱问题）
ruijiao_ren的博客
02-27 723
       关于线程安全问题，有一个很经典的问题——银行取钱问题。银行取钱的基本流程基本上可以分为以下几个步骤：       1、用户输入账户、密码，系统判断用户的账户、密码是否匹配       2、用户输入取款金额       3、系统判断取账户余额是否大于取款金额       4、如果余额大于取款金额，则取款成功；如果余额小于取款金额，则取款失败       在单一线程中这个流程没有任何问题...
银行取款[多线程]{使用同步方法确保线程同步}
weixin_34235135的博客
07-03 389
经典例子：老婆(朱丽叶)老公(罗密欧),使用银行卡和存折,或者网银等，同时对同一账户操作的安全问题。 此处用多线程实现，同时取款的模拟实现，使用同步方法确保线程同步，查看取款安全隐患问题，代码如下： --------------------------------------------------------------------------...
多线程模拟之银行取钱
星回昭以烂的博客
10-14 775
Account.java public class Account { //封装账户编号，账户余额的两个成员变量 private String accountNo; private double balance; public Account(){} //构造器 public Account(String accountNo,double balance){ this.accountNo = accountNo; this.ba
java多线程银行ATM模拟程序
11-20
在Java编程领域，多线程技术是至关重要的一个部分，特别是在设计复杂的系统，如银行ATM模拟程序时。本文将深入探讨如何利用Java实现这样的模拟程序，并涉及与多线程相关的概念。 首先，多线程是指在一个应用程序中...
使用Java多线程的同步机制编写应用程序.docx
06-22
实验结果表明，通过使用Java的多线程同步机制，我们成功地模拟了多个用户对同一银行账户的并发操作，且在所有操作完成后，账户余额保持正确，符合预期。 这个实验不仅加深了我们对并行/并发、同步/异步的理解，还...
Java实现银行存取款
08-25
在Java实现银行存取款系统中，使用了多线程编程来模拟多个用户同时进行存取款操作。多线程编程可以提高系统的并发性和响应速度。Java语言提供了多种线程机制，包括继承Thread类、实现Runnable接口和使用线程池等。 ...
C# 多线程银行账户存取简单模拟（未涉及并发互斥）
11-27
在本文中，我们将深入探讨C#编程语言中的多线程技术以及如何在银行账户模拟场景中应用它...理解并正确使用同步和互斥机制对于编写健壮的多线程程序至关重要，尤其是在银行账户这样的场景中，确保数据一致性是首要任务。
Java 多线程 模拟银行ATM实时存取钱
嘻哈嘻哈
06-08 7644
近期想回顾一些知识： 一、Java 多线程 一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销。这里定义和线程相关的另一个术语 - 进程：一个进程包括由操作系统分配的内存空间，包含一个或多个线程。一个线程不能独立的存在，它必须是进程的一部分。一个进程一直运行，直到所有的非守...
用JAVA的多线程实现银行取款的问题
fanglm的专栏
04-22 2026
packagecom.softeem.demo; /** *@authorleno *账户类 *默认有余额，可以取款 */ class Account {     private float balance = 1000;     public float getBalance() {       return balance;     }     public void setBalance(f
java多线程实现存款取款
0bug0warning的博客
11-23 6657
                                          多线程实现存款取款 我们在做一些比较大的项目的时候，可能需要用到多线程，比如我们做一个银行系统，最基本的操作，存钱，取钱。 当我们跑单线程时候存钱取钱无所谓。当我们用多线程的时候就会对线程的共享资源比如用户的余额进行控制， 保证只能存钱进程或者取钱进程中的一个进程去访问共享资源即余额。下面看实现： pac...
模拟银行取钱 (多线程操作的好处)
小肥猫吃鱼的博客
10-27 1145
(1)银行类 package test4; /**  * 银行账户  * @author user  *  */ public class Bank { private static double balance;//类的变量，数据共享 public Bank(){ } public Bank(double money){ balance = money; }
Java多线程课后题,张三和他妻子各拥有一张银行卡和存折，可以对同一个银行账户进行存取款的操作，现在余款为500，每人各取5次，每次为100元。在取款空模拟网络延迟。
weixin_46039727的博客
06-19 2403
public class Car implements Runnable { private int money=500;//余款 @Override public void run() { for (int i = 0; i < 5; i++) { synchronized (this) { money = money - 100; if (money >= 0) { System.out.println(Thread..
多线程——用同步代码块解决经典储户银行存钱问题
u012369385的专栏
08-20 2038
package com.work.wor01; /** * 需求：有两个储户同时到一个银行去存钱，每人存3次，每次存100元。 * 要求打印出银行每次金额的变化情况（假设银行没钱） * * 分析：得出有两个类：银行和储户 * 这是一个多线程的问题，如何分析他的线程安全问题呢？ * 1.通过线程的任务代码分析。 * 2.有没有共享数据，有没有多条语句在操作共享数据。 * */ cl
Java多线程高级编程：同步与线程安全
在本章中，讲解了如何使用同步代码块来模拟银行取款，通过Account类来表示账户，并创建DrawThread类来模拟取款线程。每个DrawThread实例会检查账户余额并尝试进行取款。如果在多线程环境下不使用同步，可能会出现...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

AloneDrifters

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值