三、多线程安全实例

最新推荐文章于 2023-02-28 15:11:31 发布
最新推荐文章于 2023-02-28 15:11:31 发布
阅读量560 收藏
点赞数
分类专栏： Java多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010834071/article/details/49274979
版权
     线程同步会在偶然的多线程并发访问情况下出现线程安全的情况，例如银行的取钱存钱操作等都是需要保证数据的一致性，和每次操作的线程安全。

一、线程安全问题


             现在使用2个线程来模拟银行取款操作，模拟2个人使用同一个账户并发取钱的问题。

  1.     定义Account类
     /*
     * Creation : 2015年10月15日
     */
    package com.tan.thread.bank;

    public class Account {
        private String accoutnNo; // 账号编号
        private double balance;// 余额

        public Account(String accoutnNo, double balance) {
            super();
            this.accoutnNo = accoutnNo;
            this.balance = balance;
        }

        public String getAccoutnNo() {
            return accoutnNo;
        }

        public void setAccoutnNo(String accoutnNo) {
            this.accoutnNo = accoutnNo;
        }

        public double getBalance() {
            return balance;
        }

        public void setBalance(double balance) {
            this.balance = balance;
        }

        @Override
        public boolean equals(Object obj) {
            if (this == obj) {
                return true;
            }
            if (obj != null && obj.getClass() == Account.class) {
                Account a = (Account) obj;
                return a.getAccoutnNo().equals(accoutnNo);
            }
            return false;
        }

        @Override
        public int hashCode() {
            return accoutnNo.hashCode();
        }

    }


  2. 定义取钱的线程类 DrawThread
    /*
     * Creation : 2015年10月15日
     */
    package com.tan.thread.bank;

    /**
     * 取钱操作
     */
    public class DrawThread extends Thread {
        private Account account;// 模拟账户
        private double drawMoney; // 取钱金额

        public DrawThread(String name, Account account, double drawMoney) {
            super(name);
            this.account = account;
            this.drawMoney = drawMoney;
        }

       @Override
        public void run() {
            if (account.getBalance() >= drawMoney) {
                System.out.println(getName() + "取钱成功！取了  " + drawMoney + "元");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                account.setBalance(account.getBalance() - drawMoney);
                System.out.println(getName() + ": 账户" + account.getAccoutnNo() + "剩余：" + account.getBalance());
            } else {
                System.out.println(getName() + "取钱失败");
            }
        }
           
        }
    }

  3. 主测试类

               // 创建一个账户，让两个线程来操作
            Account account = new Account("0001", 1000);
            new DrawThread("A", account, 800).start();
            new DrawThread("B", account, 800).start();

  4. 结果
      A取钱成功！取了  800.0元
    B取钱成功！取了  800.0元
    A: 账户0001剩余：200.0
    B: 账户0001剩余：-600.0

          问题出来了，账户出现了负值，这个就不是希望的结果..

二、使用同步代码块

  1.     取款的线程类
        /*
     * Creation : 2015年10月15日
     */
    package com.tan.thread.bank;

    /**
     * 取钱操作
     */
    public class DrawThread extends Thread {
        private Account account;// 模拟账户
        private double drawMoney; // 取钱金额

        public DrawThread(String name, Account account, double drawMoney) {
            super(name);
            this.account = account;
            this.drawMoney = drawMoney;
        }

        //加锁-》修改锁-》释放锁
        //使用可能并发访问的共享资源作为同步监视器
        @Override
        public void run() {
          synchronized (account) {
              if (account.getBalance() >= drawMoney) {
                  System.out.println(getName() + "取钱成功！取了  " + drawMoney + "元");
                  try {
                      Thread.sleep(1000);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
                  account.setBalance(account.getBalance() - drawMoney);
                  System.out.println(getName() + ": 账户" + account.getAccoutnNo() + "剩余：" + account.getBalance());
              } else {
                  System.out.println(getName() + "取钱失败");
              }
          }
          //释放同步锁
           
        }
    }


    注意： 任何时刻只能有一个线程可以获得对同步监视器的锁定，当同步代码块执行完成后，该线程会释放对该同步监视器的锁定。

三、使用同步方法

  1. 修改后的Account类
    /*
 * Creation : 2015年10月15日
 */
package com.tan.thread.bank;

public class Account2 {
    private String accoutnNo; // 账号编号
    private double balance;// 余额

    public Account2(String accoutnNo, double balance) {
        super();
        this.accoutnNo = accoutnNo;
        this.balance = balance;
    }

    public String getAccoutnNo() {
        return accoutnNo;
    }

    public void setAccoutnNo(String accoutnNo) {
        this.accoutnNo = accoutnNo;
    }

    public double getBalance() {
        return balance;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj != null && obj.getClass() == Account2.class) {
            Account2 a = (Account2) obj;
            return a.getAccoutnNo().equals(accoutnNo);
        }
        return false;
    }

    @Override
    public int hashCode() {
        return accoutnNo.hashCode();
    }

    /**
     * 添加一个取钱的同步方法 该方法的同步监视器是this,对于同一个账户，任何时刻只有一个线程获得对Account2对象的锁定，
     * 然后进入draw方法执行取钱操作，这样就可以保证多个线程并发取钱的线程安全。
     */
    public synchronized void draw(double drawAmount) {
        if (balance >= drawAmount) {
            System.out.println(Thread.currentThread().getName() + "取钱成功，本次取出" + drawAmount);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            balance -= drawAmount;
            System.out.println(Thread.currentThread().getName() + "取钱之后账户还剩余：" + balance);
        } else {
            System.out.println(Thread.currentThread().getName() + "取钱失败，余额不足！");
        }
    }

}


  2. 取钱操作的线程类

    /*
 * Creation : 2015年10月15日
 */
package com.tan.thread.bank;

/**
 * 取钱操作
 */
public class DrawThread2 extends Thread {
    private Account2 account2;// 模拟账户
    private double drawMoney; // 取钱金额

    public DrawThread2(String name, Account2 account2, double drawMoney) {
        super(name);
        this.account2 = account2;
        this.drawMoney = drawMoney;
    }

    @Override
    public void run() {
        account2.draw(drawMoney);
    }
}


  3. 测试如上示例

  4. 提示
    在Account类里面定义draw方法而不是在run方法中实现取钱逻辑这种做法更加符合面向对象的规则，符合DDD(领域驱动设计)


四、使用同步锁

       在实现线程安全的控制中，比较常用的是可重入锁（ReentrantLock）,使用该Lock对象可以显示的加锁、释放锁。

  1. 修改后的Account类
    /*
 * Creation : 2015年10月15日
 */
package com.tan.thread.bank;

import java.util.concurrent.locks.ReentrantLock;

public class Account3 {

    // 该锁具有可重入性，一个线程可以对已被加锁的ReentrantLock再次加锁
    private final ReentrantLock lock = new ReentrantLock(); // 定义锁对象

    private String accoutnNo; // 账号编号
    private double balance;// 余额

    public Account3(String accoutnNo, double balance) {
        this.accoutnNo = accoutnNo;
        this.balance = balance;
    }

    public String getAccoutnNo() {
        return accoutnNo;
    }

    public void setAccoutnNo(String accoutnNo) {
        this.accoutnNo = accoutnNo;
    }

    // 余额不可以随便修改，故而只能提供get方法
    public double getBalance() {
        return balance;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj != null && obj.getClass() == Account3.class) {
            Account3 a = (Account3) obj;
            return a.getAccoutnNo().equals(accoutnNo);
        }
        return false;
    }

    @Override
    public int hashCode() {
        return accoutnNo.hashCode();
    }

    public void draw(double drawAmount) {
        <strong><span style="color:#FF0000;">lock.lock();</span></strong>
        try {
            if (balance >= drawAmount) {
                System.out.println(Thread.currentThread().getName() + "取钱成功，本次取出" + drawAmount);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                balance -= drawAmount;
                System.out.println(Thread.currentThread().getName() + "取钱之后账户还剩余：" + balance);
            } else {
                System.out.println(Thread.currentThread().getName() + "取钱失败，余额不足！");
            }
        } finally {
           <strong><span style="color:#FF0000;"> lock.unlock();</span></strong>
        }

    }
}


  2. 提示

    ReentrantLock可重入锁具有可重入性，也就是说，一个线程可以对已被加锁的ReentrantLock锁再次加锁，该锁对象会维持一个计数器来追踪lock（）方法的嵌套调用，线程在每次调用lock（）加锁后，必须显示的调用unlock（）方法来释放锁，所以一段被锁的代码可以调用另一个被相同锁保护的方法。


五、死锁

  1.  程序实例

    /*
 * Creation : 2015年10月15日
 */
package com.tan.thread.bank;

/**
 * 当两个线程相互等待对方释放同步监视器时就会发生死锁
 */
public class DeadLockTest implements Runnable {
    A a = new A();
    B b = new B();

    public void init() {
        Thread.currentThread().setName("主线程");
        a.foo(b);
        System.out.println("进入主线程之后...");
    }

    @Override
    public void run() {
        Thread.currentThread().setName("副线程");
        b.bar(a);
        System.out.println("进入副线程之后...");
    }

    public static void main(String[] args) {
        DeadLockTest lockTest = new DeadLockTest();
        new Thread(lockTest).start();
        lockTest.init();
    }
}

class A {
    public synchronized void foo(B b) {
        System.out.println(Thread.currentThread().getName() + "进入A中的foo方法");
        try {
            Thread.sleep(100);
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println(Thread.currentThread().getName() + "企图调用B示例的last方法...");
        b.last();
    }

    public synchronized void last() {
        System.out.println(Thread.currentThread().getName() + "进入A类的last方法中...");
    }
}

class B {
    public synchronized void bar(A a) {
        System.out.println(Thread.currentThread().getName() + "进入B中的bar方法");
        try {
            Thread.sleep(100);
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println(Thread.currentThread().getName() + "企图调用A示例的last方法...");
        a.last();
    }

    public synchronized void last() {
        System.out.println(Thread.currentThread().getName() + "进入B类的last方法");
    }
}



谭正强
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程安全的简单示例
qf2019的博客
08-18 248
1.临界资源问题 首先我们来了解一下什么是临界资源，多道程序系统中存在许多进程，它们共享各种资源，然而有很多资源一次只能供一个进程使用。一次仅允许一个进程使用的资源称为临界资源。许多物理设备都属于临界资源，如输入机、打印机、磁带机等。 还有一个名词叫临界区，每个进程中访问临界资源的那段代码称为临界区。显然，若能保证诸进程互斥地进入自己的临界区，便可实现诸进程对临界资源的互斥访问。 我们通过下面的例子来了解一下临界资源的共用： import time import threading class Apple:
线程安全问题的详细示例
weixin_44007988的博客
09-08 170
线程安全问题的详细示例 范围太大 性能低下 同步块 锁对象 这个对象是this 与锁test2()这个方法一样 线程不安全 ticketNum对象在变 ,锁的对象不能变 线程不安全 范围太小锁不住 尽可能锁定合理的范围（不是指代码，而是指数据的完整性） package cn.com.state; public class TestSafe implements Runnable{ pr...
线程安全实例分析
m0_56188609的博客
02-28 463
线程1、2均执行方法内的代码，线程1执行get(“key”) == null，还未执行完，线程发生上下文切换轮到线程2执行，线程2也执行到此处得到的get(“key”) == null，线程2发现为null后put(“key”, v2），完成后又切换为线程1，线程1又put(“key”, v1）。② Connection也是线程安全的，Connection属于方法内的局部变量，即使有多个线程访问，线程1创建的为Connection1而线程2创建的为Connection2，两者独立互不干扰。
两个经典的线程安全示例分析
LIUZEYU12A
12-13 410
示例1：卖票与买票 @Slf4j(topic = "c.CASE1") public class CASE1 { //随机数 public static Random random = new Random(); public static int getRandom(){ return random.nextInt(5) + 1; } public static void main(String[] args) { //开始有200
线程安全问题举例
有点想法的专栏
05-01 554
文章目录1.安全问题举例1.1 多个线程操作一个对象,一个对象操作一个资源1.2 多个线程操作多个对象,多个对象操作一个资源2.同步2.1 同步块2.2 同步方法2.3 同步锁2.3.1 可重入锁ReentrantLock 1.安全问题举例 1.1 多个线程操作一个对象,一个对象操作一个资源 public class MyNumber { private Integer num; ...
线程安全例子
11-14
线程安全例子，锁的使用案例，对应博客https://blog.csdn.net/zhang5476499/article/details/83794711的例子。
java中什么是线程安全给出一个例子
mark_to_win的专栏
04-12 836
8.线程安全 什么是线程安全? 马克-to-win：最大的大白话，你的代码一个线程执行挺好，一上多线程测试就玩儿完（结果不是你所想要的），这就是线程不安全。反之为线程安全。首先，我们把第二章讲单态模式或单例模式（Singleton）的例子再搬过来一次，但这里把一些无关的打印和注释去掉了：例：1.8.1 class Photoshop { private Photoshop() { ...
基于PHP pthreads实现多线程代码实例
11-20
要使用这个扩展，就必须使用线程安全的版本。 在编译 PHP 的时候， –enable-maintainer-zts ​这个选项是必须的，其他的根据自己的需求来添加 <?php error_reporting(E_ALL); class vote extends Thread {
Java 多线程实例详解（三）
09-01
本文主要介绍 java 线程安全的知识，这里整理了相关资料及实现示例代码，有兴趣的小伙伴可以参考下
易语言实现多线程安全Hook
05-27
该模块包含了小量编程时常用的函数集：。取变量栈指针、A2W、W2A，Call（任意数量参数，内部会维护栈平衡），取函数真实地址（可为Naked函数，需自己维护栈平衡），以及部分堆函数;...Tags：多线程安全Hook。
C#多线程编程实例 线程与窗体交互源码
07-10
C#多线程编程实例 线程与窗体交互源码,该示例演示如何在线程安全的模式下调用Windows窗体上的控件。
CVI 线程锁、线程安全变量实例
11-07
该文件中实例说明了如何在Labwindows/cvi中使用线程锁和线程安全变量进行多线程程序设计
今天没事给大家写一个多线程例子
07-09
今天没事给大家写一个多线程例子 今天没事给大家写一个多线程例子
线程安全及案例
pizssn的博客
05-27 160
什么是线程安全？   多个线程同一时刻对同一个全局变量(同一份资源)做写操作(读操作不会涉及线程安全)时，如果结果跟我们预期的一样，我们就称之为线程安全，反之，线程不安全。   为了保证线程的安全，最简单的方法就是给相应的方法、对象等加synchronized关键字。 什么是synchronized？   一般说的synchronized用来做多线程同步功能，其实synchronized只是提供多线程互斥，而对象的wait()和notify()方法才提供线程的同步功能。   synchronized是加锁
多线程（线程概念、代码示例）
但行好事 无问西东
06-02 5282
进程和线程 说起进程，就必须提一下程序，程序是指令和数据的有序集合，是一个静态的概念 进程是执行程序的一次执行过程，第一个动态的概念，是系统资源分配的单位 在一个进程中包含若干个线程，线程是独立的执行路径，一个进程中至少含有一个线程，像我们已知的主线程和JC线程(垃圾回收)，即使我们没有自己创建线程，后台也会自动存在上面提到的两个和其他一些线程； 我们运行程序其实是运行的主线程，因为主方法是程序...
线程安全介绍及举例
liuerchong的博客
04-29 552
“什么是线程安全” 不是线程的安全 “什么是线程安全” ，“线程安全”也不是指线程的安全，而是指内存的安全。 目前主流操作系统都是多任务的，即多个进程同时运行。为了保证安全，每个进程只能访问分配给自己的内存空间，而不能访问别的进程的，这是由操作系统保障的。 在每个进程的内存空间中都会有一块特殊的公共区域，通常称为堆（内存）。进程内的所有线程都可以访问到该区域，这就是造成问题的潜在原因。 假...
线程安全经典案例：银行取钱问题
热门推荐
程序员云帆哥的博客
04-24 1万+
银行取钱的基本流程基本上可以分为如下几个步骤。 （1）用户输入账户、密码，系统判断用户的账户、密码是否匹配。 （2）用户输入取款密码 （3）系统判断账户余额是否大于取款余额 （4）如果余额大于取款余额，则取钱成功；如果余额小于取款余额，则取钱失败。1、先定义一个账户类，该账户类封装了账号和余额两个实例变量。
线程安全问题例子
你就像甜甜的益达
06-08 610
面试题总是会问写一个线程安全问题的例子,最简单的就是多线程操作同一个成员变量,而且方法没有加锁;如下: 解决方法可以是写一个safeMethod方法,然后直接使用synchronized 关键字, 也可以使用AtomicInteger ,直接使用incrementAndGet方法.基于cas操作的进行增加也是线程安全的 import java.util.concurrent.CompletableFuture; import java.util.concurrent.CountDownLatch;
SimpleDateFormat多线程不安全
最新发布
09-14
是的，SimpleDateFormat类在多线程环境下不是线程安全的。SimpleDateFormat类是用于格式化和解析日期的类，它继承自java.text.DateFormat，并实现了Serializable接口。它的实例可以被多个线程同时访问，但是它的内部...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值