常见的锁策略

已于 2023-04-21 18:03:54 修改
阅读量95 收藏
点赞数
分类专栏： JavaEE 文章标签： java jvm
于 2022-11-08 20:39:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52463861/article/details/127755887
版权

一、乐观锁 & 悲观锁

1.1乐观锁

1.1.1乐观锁的定义：

乐观锁认为⼀般情况下不会出现冲突，所以只会在更新数据的时候才对冲突进行检测，如果发生没有发生冲突直接进行修改，如果发生冲突了不做任何修改，然后把结果返回给用户，让用户自行决定处理。

1.1.2乐观锁的实现——CAS

CAS 比较并替换机制
流程：
CAS 中包含了三个操作单位：
V（内存值，）、A（预期的旧址）、B（新值），比较 V 值和 A 是否相等，如果相等的话说明没有发生锁冲突,则将 V值更换成 B值；否则说明发生了锁冲突，乐观锁执行失败，就提示用户修改失败，从而实现了 CAS 的机制。

1.1.3CAS应用

CAS的底层实现是靠Unsafe类实现的，Unsafe是CAS的核心类，在getAndIncrement方法中还调用了unsafe的方法，因此我们可以利用Atomic+包装类实现线程安全的问题。

import java.util.concurrent.atomic.AtomicInteger;

public class CASDemo1 {
    private static int number = 0;
    private static AtomicInteger atomicInteger = new AtomicInteger(0);
    private final static int MAX_COUNT = 100000;

    public static void main(String[] args) throws InterruptedException {

//        System.out.println("执行结果："+atomicInteger.get());
//        //++
//        atomicInteger.getAndIncrement();
//        System.out.println("++:"+atomicInteger.get());
//
//        //--
//        atomicInteger.getAndDecrement();
//        System.out.println("--:"+atomicInteger.get());


        //++
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < MAX_COUNT; i++) {
                atomicInteger.getAndIncrement();
                //number ++;
            }
        });
        t1.start();


        //--
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < MAX_COUNT; i++) {
                atomicInteger.getAndDecrement();
                //number --;
            }
        });
        t2.start();

        t1.join();
        t2.join();
        System.out.println("最终结果："+atomicInteger.get());
    }

}

在这里插入图片描述

1.1.4ABA问题

CSA的缺点是存在ABA问题
ABA问题描述：
A有100元，A向B转钱，第一次转了50元，但是点完转账按钮没有反应，于是又点击了一次。第一次转账成功后A还剩50元，而这时C给A转了50元，A的余额变为100元，第二次的CAS判断（100，100，50），A的余额与预期的值一样，于是将A的余额修改为50元。

//ABA问题演示
import java.util.concurrent.atomic.AtomicInteger;

public class ABADemo1 {
    private static AtomicInteger money = new AtomicInteger(100);

    public static void main(String[] args) throws InterruptedException {
        //第一次点击转账按钮 -50
        Thread t1 = new Thread(() -> {
            int old_money = money.get();
            //花费了2s
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            money.compareAndSet(old_money,old_money - 50);
        });
        t1.start();


        //第二次点击转账按钮 -50（不小心点击的，因为第一次点击之后没有反应）
        Thread t2 = new Thread(() -> {
            int old_money = money.get();
            money.compareAndSet(100,50);
            money.compareAndSet(old_money,old_money - 50);
        });
        t2.start();

        //给账户+50元
        Thread t3 = new Thread(() -> {
            //花费了1s
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            int old_money = money.get();
            money.compareAndSet(old_money,old_money + 50);
        });
        t3.start();

        t1.join();
        t2.join();
        t3.join();
        System.out.println("最终账户余额："+money.get());
    }
}

在这里插入图片描述

1.1.5ABA问题解决

ABA解决⽅案：引入版本号AtomicStampedReference
每次操作之后让版本号+1，执行的时候判断版本号和值，就可以解决问题。

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicStampedReference;

/**
 * ABA问题解决
 */
public class ABADemo2 {
    private static AtomicStampedReference<Integer> money =
            new AtomicStampedReference(100,0);

    public static void main(String[] args) throws InterruptedException {
        //第一次点击转账按钮 -50
        Thread t1 = new Thread(() -> {
            int old_money = money.getReference();//得到余额
            int version = money.getStamp();//得到版本号
            //花费了2s
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            money.compareAndSet(old_money,old_money - 50,version,version + 1);
        });
        t1.start();


        //第二次点击转账按钮 -50（不小心点击的，因为第一次点击之后没有反应）
        Thread t2 = new Thread(() -> {
            int old_money = money.getReference();//得到余额
            int version = money.getStamp();//得到版本号
            money.compareAndSet(old_money,old_money - 50,version,version + 1);
        });
        t2.start();

        //给账户+50元
        Thread t3 = new Thread(() -> {
            //花费了1s
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            int old_money = money.getReference();
            int version = money.getStamp();
            money.compareAndSet(old_money,old_money + 50,version,version + 1);
        });
        t3.start();

        t1.join();
        t2.join();
        t3.join();
        System.out.println("最终账户余额："+money.getReference());
    }
}

在这里插入图片描述

1.2 悲观锁

悲观锁就是比较悲观，总是假设最坏的情况，每次去拿数据的时候都会认为别人会修改，所以在每次拿数据的时候都会上锁，这样别人想拿数据就会阻塞直到它拿到锁。

比如我们之前提到的synchronized和Lock都是悲观锁。

二、公平锁 & 非公平锁

公平锁：按照线程来的先后顺序获取锁，当一个线程释放锁之后，那么就唤醒阻塞队列中第一个线程获取锁。
非公平锁：不是按照线程来的先后顺序唤醒锁，而是当有一个线程释放锁之后，唤醒阻塞队列中的所有线程，随机获取锁。
大多数锁默认为非公平锁，因为非公平锁的效率更高。

非公平锁：ReentrantLock lock = new ReentrantLock(false)。如果构造函数不传递参数，则默认是⾮公平锁。
非公平锁：ReentrantLock lock = new ReentrantLock(false)。如果构造函数不传递参数，则默认非公平锁。

三、读写锁

3.1读写锁

把一把锁分为两部分：读锁和写锁
读锁允许多个线程同时获得，写锁是互斥锁，不允许多个线程同时获得。
读写锁的特点是：读读不互斥、读写互斥、写写互斥。
使用场景：多读少写的业务操作，使用读写锁可以发挥到最大性能。

Java 标准库提供了 ReentrantReadWriteLock 类, 实现了读写锁.
1.ReentrantReadWriteLock.ReadLock 类表示⼀个读锁. 这个对象提供了 lock / unlock 方法进行加锁解锁.
2.ReentrantReadWriteLock.WriteLock 类表示⼀个写锁. 这个对象也提供了 lock / unlock方法进行加锁解锁.

import java.time.LocalDateTime;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 演示读写锁的使用
 */
public class ReadWriteLockDemo {
    public static void main(String[] args) {
        //创建读写锁
        final ReentrantReadWriteLock reentrantReadWriteLock=new ReentrantReadWriteLock();
        //创建读锁
        final ReentrantReadWriteLock.ReadLock readLock= reentrantReadWriteLock.readLock();
        //创建写锁
        final ReentrantReadWriteLock.WriteLock writeLock= reentrantReadWriteLock.writeLock();
        //线程池
        ThreadPoolExecutor executor=new ThreadPoolExecutor(5,5,0, TimeUnit.SECONDS,new LinkedBlockingDeque<>(100));
        //启动线程执行任务【读操作1】
        executor.submit(()->{
            //加锁操作
            readLock.lock();
            try{
                //执行业务逻辑
                System.out.println("执行读锁1："+ LocalDateTime.now());
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                readLock.unlock();
            }
        });

        //启动线程执行任务【读操作2】
        executor.submit(()->{
            //加锁操作
            readLock.lock();
            try{
                //执行业务逻辑
                System.out.println("执行读锁2："+ LocalDateTime.now());
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                //释放锁
                readLock.unlock();
            }
        });

        //启动线程执行【写操作1】
        executor.submit(()->{
            //加锁
            writeLock.lock();
            try {
                System.out.println("执行写锁1："+LocalDateTime.now());
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                writeLock.unlock();
            }
        });

        //启动线程执行【写操作2】
        executor.submit(()->{
            //加锁
            writeLock.lock();
            try {
                System.out.println("执行写锁2："+LocalDateTime.now());
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                writeLock.unlock();
            }
        });
    }
}

在这里插入图片描述

3.2独占锁

独占锁就是指任何时候只能有一个线程能执行资源操作，是互斥的。
比如写锁，就是一个独占锁，任何时候只能有一个线程执行写操作，synchronized、Lock都是独占锁。

3.3共享锁

共享锁是指可以同时被多个线程获取，但是只能被一个线程修改。读写锁(读读不互斥) 就是一个典型的共享锁，它允许多个线程进行读操作 ，但是只允许一个线程进行写操作。

三、可重入锁和自旋锁

3.1可重入锁

可重⼊锁指的是该线程获取了该锁之后，可以无限次的进⼊该锁锁住的代码。
synchronized、ReentrantLock都是可重入锁。

3.2自旋锁

⾃旋锁是指尝试获取锁的线程不会⽴即阻塞，⽽是采用循环的方式去尝试获取锁，这样的好处是减少线程上下⽂切换的消耗，缺点是循环会消耗 CPU。

努力加油鸭！
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Redis分布式锁存在的问题及解决方案（值得珍藏）
01-20
Redis分布式锁在实现跨进程、跨机器的互斥访问时，虽功能强大，但也存在一些常见问题。这些问题主要源于网络延迟、系统时钟误差以及Redis自身的特性。 一个典型问题是锁的"死锁"现象，即因进程意外终止或网络故障，...
常见锁策略
qq_66292058的博客
03-17 839
本篇将介绍一些常见的锁策略和原子操作CAS。
synchronized常见锁策略
a512512a的博客
02-13 1554
讲述了synchronized中常见的锁策略，包括乐观锁，悲观锁，轻量级锁，重量级锁，读写锁，公平锁，等等一系列锁的原理
理解这些常见锁策略，恭喜你，又进阶了~
CYK_byte的博客
09-21 1277
具体介绍，上面已经很清楚了，忘了的话，记得往上翻翻；问道为什么要使用自旋策略，实际上就是再问你，自旋锁的优点是什么，最好把缺点也说一下，面试官一天要面试很多人，而面试官实际上和你是站在一方的，就是一个让你展现自我的地方，所以，面试官自然是希望多说点你了解的。
常见锁策略—乐观锁&悲观锁
weixin_46972127的博客
04-18 3558
目录 1、乐观锁&悲观锁 1.1 乐观锁的定义 1.2 乐观锁的实现（CAS机制） 1.3 乐观锁存在的问题：ABA问题 1.4 悲观锁 2、公平锁&非公平锁 3、读写锁 4、独占锁&共享锁 5、可重入锁&自旋锁 1、乐观锁&悲观锁 1.1 乐观锁的定义 乐观锁认为一般情况下不会出现冲突，所以只会在更新数据的时候才对冲突进行数据检测，如果没有发生冲突则直接修改，如果发生冲突则不做任何修改，然后把结果返回给用户，让用户自行处理。 1.2
详解 —— 常见锁策略及ABA问题
lingxu6的博客
05-02 814
目录 一、常见锁策略 1、悲观锁VS乐观锁 2、读写锁VS普通互斥锁 3、重量级锁VS轻量级锁 4.挂起等待锁VS自旋锁 5、公平锁VS非公平锁 6、可重入锁VS不可重入锁 小结 二、CAS 1、CAS的作用 2、ABA问题 三、synchronized的锁优化机制 1.锁膨胀/锁升级 2、锁粗化 3、锁消除 一、常见锁策略 一般来说，锁策略和普通的程序员基本没啥关系，跟实现锁的人有紧密的联系。这里提到的锁策略也不是局限于Java这门语言的，是适用于所有跟锁...
Redis缓存常用4种策略原理详解
01-19
最常见的几种缓存策略、它们的优缺点以及使用场景，分别是： Cache-Aside Read-Through Write-Through Write-Behind Cache-Aside 策略 Cache-Aside可能是最常用的缓存策略。在这种策略下，应用程序(Application)...
redis常见面试题汇总
01-07
一. redis的数据类型，以及每种数据...回答: redis采用定期清除和惰性删除的策略 redis 并不是每隔100ms 扫描全部的key 而是根据随机抽取一定得key 进行检查key 是否过期， redis 也会在你获取某个key的时候进行检查
Android唤醒锁检测及功耗优化机制
05-06
本文分析总结了常见的唤醒锁误用类型及原因，并实现了一款安卓应用，用以检测当前系统中持有唤醒锁的进程，并根据某些策略释放误用的唤醒锁.结合具体实机测试数据，本文提出的检测机制及功耗优化方法，可有效降低...
别让用户发呆—设计中的防呆策略
03-02
生活中总会有些状况让我们无所适从摸不着头脑：面对一排电灯或空调的按钮，哪个才是控制我想要的？开锁时掏出一把钥匙，哪个才是正确的？拿起U盘插入电脑，朝那个...最常见的防呆设计在电脑中，为了让普通用户在组装
jar包增量更新分析
junlaiyan的专栏
05-16 391
借助jdeps分析出jar包的增量文件
docker中安装jenkins，并在node和cloud上跑通基于源码控制SCM的pipeline
qq_29022265的博客
05-19 1097
从安装jenkins到创建jenkins的node和cloud，最后再将scm和FreeStyle两种流水线跑通。
java实现拼图小游戏
monkey108的博客
05-16 708
本文主要提供用java实现的拼图小游戏源代码。
分布式锁2-Zookeeper分布式锁实战
最新发布
qq_43676797的博客
05-19 232
使用curator操作Zookeeper进行实战；：Apache Curator包含一套高级API框架和工具类，它 是Apache ZooKeeper 的Java 客户端库。
命令执行漏洞（二）
XLbb的博客
05-15 1018
POST方法，S2-045-bypass-2漏洞存在！,程序更改为S2-045-bypass-2漏洞测试模式, 响应码: 200。POST方法，S2-046-bypass漏洞存在！POST方法，S2-045-bypass漏洞存在！POST方法，S2-046-1漏洞存在！POST方法，S2-046-2漏洞存在！POST方法，S2-046-3漏洞存在！POST方法，S2-045-1漏洞存在！POST方法，S2-045-3漏洞存在！POST方法，S2-045-2漏洞存在！POST方法，S2-045-4漏洞存在！
java数据结构与算法(验证二叉搜索树)
磐门的博客
05-17 356
节点返回空为ture,节点的值不在对应数据大小范围内返回false。将验证二叉搜索树计算同样可以转换为相同子问题，所以比较适合用递归。node为root的左节点时，max更新为root.val。node为root的右节点时，min更新为root.val。
SpringMVC基础
Java小白的博客 致力分享每一天学到的知识
05-15 1331
介绍了有关SpringMVC的基础内容
Kubernetes 审计日志采集与分析最佳实践
观测云的博客
05-17 1085
​Kubernetes 在 1.7 版本中发布了审计（Audit）日志功能，通过审计日志，我们能够非常清晰的知道 K8S 集群到底发生了什么事情。
Android Model引入其他aar包 导致无法打包成aar
qq_27400335的博客
05-16 379
Android Model引入其他aar包 导致无法打包成aar
C# 设计锁的使用策略
07-27
下面是一些常见的锁使用策略： 1. 锁定共享资源：当多个线程需要访问同一个共享资源时，使用 lock 关键字将代码块包裹起来，确保同一时间只有一个线程可以进入临界区，避免并发访问问题。 ```csharp lock ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值