多线程的锁

最新推荐文章于 2022-11-03 18:40:48 发布
最新推荐文章于 2022-11-03 18:40:48 发布
阅读量387 收藏 2
点赞数
分类专栏： 多线程 文章标签： 多线程 锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_19925065/article/details/52399452
版权

一、在没有锁的情况下，举例下面的例子
（1）Account类，账户类，包括账户号码和余额

package cn.test.synchronization.one;

public class Account {
    private String accountNo;
    private double balance;

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

    public String getAccountNo() {
        return accountNo;
    }

    public void setAccountNo(String accountNo) {
        this.accountNo = accountNo;
    }

    public double getBalance() {
        return balance;
    }

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

    public int hashCode(){
        return accountNo.hashCode();
    }

    public boolean equals(Object obj){
        if(obj != null && obj.getClass() == Account.class){
            Account target = (Account)obj;
            return target.getAccountNo().equals(accountNo);
        }
        return false;
    }

}

（2）DrawThread 取钱类，包括账户实体和取钱金额

package cn.test.synchronization.one;

public class DrawThread extends Thread{
    private Account account;
    private double drawAmount;

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

    public void run(){
        if(account.getBalance() >= drawAmount){
            System.out.println(getName()+"取钱成功！吐出钞票："+drawAmount);

            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //修改余额
            account.setBalance(account.getBalance() - drawAmount);
            System.out.println("\t 余额为："+account.getBalance());

        }else{
            System.out.println(getName() + "取钱失败！余额不足");
        }
    }

}

注意这个类中的run()方法实现了取钱的过程，按道理这不是面向对象的思想在编程，在面向对象中有一个设计模式叫领域驱动模式，强调把类的功能应该放在类里面。

（3）测试类：

package cn.test.synchronization.one;

public class TestDraw {
    public static void main(String[] args) {
        //创建一个账户
        Account account = new Account("12345", 1000);
        new DrawThread("甲", account, 800).start();
        new DrawThread("乙", account, 800).start();
    }
}

执行出现的结果：

乙取钱成功！吐出钞票：800.0
甲取钱成功！吐出钞票：800.0
     余额为：200.0
     余额为：-600.0

明显，由于run方法线程不安全的问题出现了以上异常的结果。
由此我们引出了线程锁的问题。关于锁的问题，有三种方式：
1、snychronize(){} ：括号里面是对竞争资源的锁，这种方式是对属性加锁，而属性就是竞争资源
2、public snychronize void 方法名(){} : 这种是对this进行加锁
3、前面两种锁不能显示地加锁和显示地解锁，而这种方式就能完美的解决。同步锁（Lock），在实现多线程的安全控制中，通常喜欢用ReentrantLock(可重入锁)。使用该所进行显示加锁、显示释放锁。

二、snychronize(){}
（1）Account类，同上
（2）DrawThread，取钱类

package cn.test.synchronization.two;

public class DrawThread extends Thread{
    private Account account;
    private double drawAmount;

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

    public void run(){
        //synchronized可以修饰方法，可以修饰代码块，但不能修饰构造器、属性等等
        synchronized (account) {   
            if(account.getBalance() >= drawAmount){
                System.out.println(getName()+"取钱成功！吐出钞票："+drawAmount);

                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //修改余额
                account.setBalance(account.getBalance() - drawAmount);
                System.out.println("\t 余额为："+account.getBalance());

            }else{
                System.out.println(getName() + "取钱失败！余额不足");
            }
        }

    }

}

（3）测试类，同上

执行的结果是：

甲取钱成功！吐出钞票：800.0
     余额为：200.0
乙取钱失败！余额不足

显然，没有出现异常。
三、public snychronize void 方法名(){}
（1）Account类，账户类

package cn.test.synchronization.three;

public class Account {
    private String accountNo;
    private double balance;

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

    public String getAccountNo() {
        return accountNo;
    }

    public void setAccountNo(String accountNo) {
        this.accountNo = accountNo;
    }

    public double getBalance() {
        return balance;
    }


    public int hashCode(){
        return accountNo.hashCode();
    }

    public boolean equals(Object obj){
        if(obj != null && obj.getClass() == Account.class){
            Account target = (Account)obj;
            return target.getAccountNo().equals(accountNo);
        }
        return false;
    }

    //将draw()方法放在Account类中更符合面向对象的思想，在面向对象有一种设计模式叫
    //领域驱动模式
    //凡事具有两面性，加了synchronized方法使得可变类更加的安全，但是这种安全是有代价的，
    //它是以降低程序的运行效率作为代价，所以我们有以下两点建议：
    //1、不对不可变类进行线程同步，不需要；只对可变类的竞争资源进行同步，对可变类的其他资源不
    //   进行同步，因为这会影响运行效率
    //2、可变类运行在两种运行环境（1、单线程环境，2、多线程环境），那么最好为可变类提供两个版本
    ///  这样可以保证性能
    public synchronized void draw(double drawAmount){
        if(this.getBalance() >= drawAmount){
            System.out.println(Thread.currentThread().getName()+"取钱成功！吐出钞票："+drawAmount);

            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //修改余额
            this.balance = this.balance - drawAmount;
            System.out.println("\t 余额为："+this.getBalance());

        }else{
            System.out.println(Thread.currentThread().getName() + "取钱失败！余额不足");
        }
    }

}

（2）DrawThread，取钱类

package cn.test.synchronization.three;

public class DrawThread extends Thread{
    private Account account;
    private double drawAmount;

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

    public void run(){
        account.draw(drawAmount);
    }

}

（3）测试类，同上

运行结果与二相同。

=================================
这里写图片描述

可变类与不可变类讲解
凡事具有两面性，加了synchronized使得可变类更加的安全，但是这种安全是有代价的，它是以降低程序的运行效率作为代价，所以我们有以下两点建议：
1、不对不可变类进行线程同步，不需要；只对可变类的竞争资源进行同步，对可变类的其他资源不进行线程同步，因为这会影响运行效率
2、可变类运行在两种运行环境（1、单线程环境，2、多线程环境），那么最好为可变类提供两个版本，这样可以保证性能

这里写图片描述

前面两种线程同步的方式都无法显示地释放同步监视器，那么什么时候才会自动地释放同步监视器呢？
1、以下情况会自动释放同步监视器：
（1）同步方法或同步代码块已经执行完毕。包括（同步方法或同步代码块执行完最后一行、遇到break跳出同步方法或同步代码块、遇到return终止执行同步方法或同步代码块）
（2）当线程在同步方法或同步代码块遇到未处理的Error或Exception，导致异常结束时会释放同步监视器
（3）同步监视器监视的对象执行wait()方法，释放同步监视器
2、以下情况不会自动释放同步监视器：
（1）线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()（线程让步）方法来暂停当前线程的执行、当前线程不会释放同步监视器
（2）线程执行同步代码块或同步方法时，其他线程调用了该线程的suspend方法将该线程挂起，该线程不会释放同步监视器

=================================

三、同步锁
（1）Account类，账户类

package cn.test.synchronization.four;

import java.util.concurrent.locks.ReentrantLock;

public class Account {
    //定义锁对象，可重入锁
    private final ReentrantLock lock = new ReentrantLock();

    private String accountNo;
    private double balance;

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

    public String getAccountNo() {
        return accountNo;
    }

    public void setAccountNo(String accountNo) {
        this.accountNo = accountNo;
    }

    public double getBalance() {
        return balance;
    }


    public int hashCode(){
        return accountNo.hashCode();
    }

    public boolean equals(Object obj){
        if(obj != null && obj.getClass() == Account.class){
            Account target = (Account)obj;
            return target.getAccountNo().equals(accountNo);
        }
        return false;
    }

    //将draw()方法放在Account类中更符合面向对象的思想，在面向对象有一种设计模式叫
    //领域驱动模式
    //凡事具有两面性，加了synchronized方法使得可变类更加的安全，但是这种安全是有代价的，
    //它是以降低程序的运行效率作为代价，所以我们有以下两点建议：
    //1、不对不可变类进行线程同步，不需要；只对可变类的竞争资源进行同步，对可变类的其他资源不
    //   进行同步，因为这会影响运行效率
    //2、可变类运行在两种运行环境（1、单线程环境，2、多线程环境），那么最好为可变类提供两个版本
    ///  这样可以保证性能
    public void draw(double drawAmount){
        //对同步锁进行加锁
        lock.lock();
        try{
            if(this.getBalance() >= drawAmount){
                System.out.println(Thread.currentThread().getName()+"取钱成功！吐出钞票："+drawAmount);

                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //修改余额
                this.balance = this.balance - drawAmount;
                System.out.println("\t 余额为："+this.getBalance());

            }else{
                System.out.println(Thread.currentThread().getName() + "取钱失败！余额不足");
            }
        }finally {
            lock.unlock();
        }

    }

}

（2）DrawThread类，取钱类

package cn.test.synchronization.four;

public class DrawThread extends Thread{
    private Account account;
    private double drawAmount;

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

    public void run(){
        account.draw(drawAmount);
    }

}

（3）测试类，同上

===============

避免死锁的几个方法：
·避免一个线程同时获取多个锁。
·避免一个线程在锁内同时占用多个资源，尽量保证每个锁只占用一个资源。
·尝试使用定时锁，使用lock.tryLock（timeout）来替代使用内部锁机制。
·对于数据库锁，加锁和解锁必须在一个数据库连接里，否则会出现解锁失败的情况。

陈俊成
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程锁机制相关原理实例解析
08-18
主要介绍了Java多线程锁机制相关原理实例解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
多线程--锁 详解
qq_36657997的博客
03-08 500
多线程–锁 Synchorized 1 CAS 1.1 CAS概念 ​ CAS 即 （Compare And Swap / Compare And Set /Compare And Exchange）比较并交换，一种实现并发算法时用到的技术，是 JAVA 很多底层并发包的实现原理。 1.2 案例 先做一个实验，示例如下： public static volatile int v1 = 0; //定义一个共享变量 public staic void incease1(){ //自增 v1++; }
5. 多线程锁
LanChaoHui的博客
08-19 123
多线程锁
C#多线程锁
木心算法
04-18 5786
c#多线程操作队列
06. 多线程锁原理
NorthStar的博客
07-27 1589
锁原理
Java多线程(四)线程锁
yuanchun的知识整理
11-03 4512
Java多线程(四)线程锁
多线程锁的使用规范
02-09
多线程锁使用规范： 【规则1】定义的锁及保护的对象要放在一起声明，同时注明该锁要保护的对象。例如在类的声明中，声明一个m_objA成员变量，和保护此变量的锁m_mutexObjA.....
Linux多线程锁属性设置方法
09-15
下面小编就为大家带来一篇Linux多线程锁属性设置方法。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
多线程锁的解释范例
07-03
通过账户的取款问题解释java的多线程，线程锁问题,eclipse源代码。
多线程锁原理和实现案例
01-07
设计多线程锁操作系统实现原理、有哪些多线程锁，如何使用这些锁
这把“锁”不简单，让你畅游数字世界
华为云官方博客
02-22 2209
摘要：细心的你也一定关注到，有的网址是https开头的，有的是http。https开头的网站前面，会有一把小锁。这是为什么呢？
android手机应用源码Imsdroid语音视频通话源码.rar
05-20
android手机应用源码Imsdroid语音视频通话源码.rar
营销计划汇报PPT，市场品牌 推广渠道 产品 营销策略tbb.pptx
05-20
营销计划汇报PPT，市场品牌 推广渠道 产品 营销策略tbb.pptx
JavaScript_超过100种语言的纯Javascript OCR.zip
05-20
JavaScript
JavaScript_跨平台React UI包.zip
05-20
JavaScript
node-v16.17.0-headers.tar.xz
最新发布
05-20
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
520表白代码.rar
05-20
520表白html5爱心代码
一个简单的HTML5和CSS代码示例，用于创建一个动态的爱心形状，并在网页上展示一个类似520表白的消息 这个示例使用了CSS的
05-20
520表白html5爱心代码 一个简单的HTML5和CSS代码示例，用于创建一个动态的爱心形状，并在网页上展示一个类似520表白的消息。这个示例使用了CSS的动画效果和HTML的结构。
智慧养老社区方案.pdf
05-20
智慧养老社区方案.pdf
python 多线程锁
04-05
在多线程应用中，锁是一种机制，它可以确保同一时间只有一个线程能够访问共享资源。在 Python 中，可以使用 threading.Lock() 函数来创建锁对象。使用锁对象的 acquire() 和 release() 方法可以分别获取和释放锁。 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值