锁策略总结

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

乐观锁

乐观锁：它认为一般情况下不会发生并发冲突，所以只有在进行数据更新的时候，才会检测并发冲突，如果没有冲突，则直接修改，如果有冲突，则返回失败。

CAS（Compare And Swap 比较并且交换）：
V（内存值）
A（旧值）
B（新值）
具体流程：V==A?true(没有并发冲突)->V=B; : false(并发冲突)

线程的解决方案：加锁、ThreadLocal、Atomic*

乐观锁 Atomic*

我们先来看一个示例：

public class ThreadDemoGJ1 {
    private  static int count = 0;
    private static final int maxSize = 100000; //最大循环次数

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < maxSize; i++) {
                    count++;
                }
            }
        });
        t1.start();
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < maxSize; i++) {
                    count--;
                }
            }
        });
        t2.start();
        t1.join();
        t2.join();
        System.out.println("结果： " + count);
    }
}

在这里插入图片描述
发现结果不为0，因为有并发冲突
接下来我们采用乐观搜：

import java.util.concurrent.atomic.AtomicInteger;

public class ThreadDemoGJ2 {
    private  static AtomicInteger count = new AtomicInteger(0);
    private static final int maxSize = 100000; //最大循环次数

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < maxSize; i++) {
                    //count++;
                    count.getAndIncrement();
                }
            }
        });
        t1.start();
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < maxSize; i++) {
                    //count--;
                    count.getAndDecrement();
                }
            }
        });
        t2.start();
        t1.join();
        t2.join();
        System.out.println("结果： " + count);


//        AtomicInteger count = new AtomicInteger(0);
//        count.getAndIncrement();  //i++
//        count.incrementAndGet();  //++i
    }
}

在这里插入图片描述

CAS底层实现原理：
答：Java层面CAS的实现是UnSafe类
Unsafe类调用了C++的本地方法，通过调用操作系统的Atomic：：cmpxchg来实现CAS

优点：性能比高

缺点：ABA问题 ->上面代码中的AtomicInteger 是存在ABA问题的 A：预期旧值 B：新值

演示一下ABA问题：
在这里插入图片描述

import java.util.concurrent.atomic.AtomicReference;

/**
 * ABA 问题演示
 */
public class ThreadDemoGJ4 {
    private static AtomicReference money = new AtomicReference(100);
    public static void main(String[] args) throws InterruptedException {
        //转账线程1（-100）
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                //转账
                boolean result =  money.compareAndSet(100,0);
                System.out.println("转账线程1（-100）"+result);
            }
        });
        t1.start();
        t1.join();
        //转入100元
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                //+100
               boolean result =  money.compareAndSet(0,100);
                System.out.println("转入100（+100）"+result);
            }
        });
        t3.start();
        t3.join();
        //转账线程2（-100）
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                //转账
                boolean result =  money.compareAndSet(100,0);
                System.out.println("转账线程2（-100）"+result);
            }
        });
        t2.start();
    }
}

在这里插入图片描述
发现t3转入的一百元影响了t2的执行。本来预想结果第二次转账应该是是失败的，因为余额没有100元。

那么如何解决这个问题呢？

ABA统一解决方案：增加版本号，每次修改之后，更新版本号。（AtomicStampedReference）添加了版本号
演示：

import java.util.concurrent.atomic.AtomicStampedReference;

/**
 * 解决ABA问题
 */
public class ThreadDemoGJ5 {
    private static AtomicStampedReference money = new AtomicStampedReference(100,1);
    public static void main(String[] args) throws InterruptedException {
        //转账线程1（-100）
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                //转账
                boolean result =  money.compareAndSet(100,0,1,2);
                System.out.println("转账线程1（-100）"+result);
            }
        });
        t1.start();
        t1.join();
        //转入100元
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                //+100
               boolean result =  money.compareAndSet(0,100,2,3);
                System.out.println("转入100（+100）"+result);
            }
        });
        t3.start();
        t3.join();
        //转账线程2（-100）
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                //转账
                boolean result =  money.compareAndSet(100,0,1,2);
                System.out.println("转账线程2（-100）"+result);
            }
        });
        t2.start();
    }
}

在这里插入图片描述
这次发现第二次转账失败了，因为两次转账的版本号不同。

那如果把金额改为1000呢？我们来看看

import java.util.concurrent.atomic.AtomicStampedReference;

/**
 * 解决ABA问题
 */
public class ThreadDemoGJ6 {
    private static AtomicStampedReference money = new AtomicStampedReference(1000,1);
    public static void main(String[] args) throws InterruptedException {
        //转账线程1（-100）
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                //转账
                boolean result =  money.compareAndSet(1000,0,1,2);
                System.out.println("转账线程1（-1000）"+result);
            }
        });
        t1.start();
        t1.join();
        //转入100元
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                //+100
               boolean result =  money.compareAndSet(0,1000,2,3);
                System.out.println("转入1000（+1000）"+result);
            }
        });
        t3.start();
        t3.join();
        //转账线程2（-100）
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                //转账
                boolean result =  money.compareAndSet(1000,0,1,2);
                System.out.println("转账线程2（-1000）"+result);
            }
        });
        t2.start();
    }
}

在这里插入图片描述
发现三次操作都失败了，那是因为Integer高速缓存（-127 -> +128）
设置应用程序参数（-D） ，设置Integer高速缓存的最大值：
在这里插入图片描述

悲观锁

悲观锁：他认为通常情况下会出现并发冲突，所以在进入方法之后就会进行检测。
！！！synchronized是悲观锁。

怎么理解乐观锁和悲观锁的，具体怎么实现呢？
答：乐观锁->CAS->Atomic*，CAS组成是由三个东西组成：V （内存值）A（预期旧值） B（新值）组成。执行的时候使用V==A，如果为true，则表明没有并发冲突，则可以直接修改，否则不能修改。CAS通过C++提供的UnSafe中的本地方法实现的（CompareAndSwapXXX）。C++是通过调用系统的Atomic：：cmpxchg（原子指令）来实现的
悲观锁：->synchronized 在Java中是将锁的id存放到到对象头中。synchronized在jvm层面是通过监视器锁来实现，在操作系统层面是通过互斥锁mutex实现。

synchronized优化（锁消除）：
JDK1.6锁升级过程：
无锁
偏向锁（第一个线程第一次访问）将线程id放在对象头中的偏向锁标识。
轻量级锁（自旋）
重量级锁

共享锁与非共享锁

共享锁：一把可以被多个线程拥有，这就叫共享锁
读写锁中的读锁就是共享锁。
非共享锁（独占锁）：一把锁只能被一个线程拥有，这就叫非共享锁。
synchronized是非共享锁

读写锁

读写锁：就是将一把锁分成两个，一个用于读数据的锁，另一把锁叫做写锁。读锁可以被多个线程同时拥有，而写锁只能被一个线程拥有。

读写锁的具体实现：

import java.util.Date;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ThreadDemoGJ7 {
    public static void main(String[] args) {
        //创建一个读写锁
        ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
        //读锁
        ReentrantReadWriteLock.ReadLock readLock = reentrantReadWriteLock.readLock();
        //写锁
        ReentrantReadWriteLock.WriteLock writeLock = reentrantReadWriteLock.writeLock();

        //线程池
        ThreadPoolExecutor executor = new ThreadPoolExecutor(10,10,0, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(1000));

        //任务1：读锁
        executor.execute(new Runnable() {
            @Override
            public void run() {
                //加锁
                readLock.lock();
                try{
                    //业务逻辑处理
                    System.out.println(Thread.currentThread().getName() + "执行了读锁操作" + new Date());

                        Thread.sleep(3000);
                } catch (InterruptedException e) {
                        e.printStackTrace();
                }finally {
                    readLock.unlock();
                }
            }
        });
        //任务2：读锁
        executor.execute(new Runnable() {
            @Override
            public void run() {
                //加锁
                readLock.lock();
                try{
                    //业务逻辑处理
                    System.out.println(Thread.currentThread().getName() + "执行了读锁操作" + new Date());

                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    readLock.unlock();
                }
            }
        });
        //任务3：写锁
        executor.execute(new Runnable() {
            @Override
            public void run() {
                writeLock.lock();
                try{
                    System.out.println(Thread.currentThread().getName()+ "执行了写锁操作" + new Date());
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    writeLock.unlock();
                }
            }
        });
        //任务4：写锁
        executor.execute(new Runnable() {
            @Override
            public void run() {
                writeLock.lock();
                try{
                    System.out.println(Thread.currentThread().getName()+ "执行了写锁操作" + new Date());
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    writeLock.unlock();
                }
            }
        });
    }

}

在这里插入图片描述
可以发现，两个线程的读操作的时间是一致的，而写操作不一致，说明了读锁是共享锁，而写锁是非共享锁。

读写锁的优势：锁的力度更加的小，性能也更高。
注意事项：读写锁中的读锁和写锁是互斥的，防止同时读写所产生的脏数据。

公平锁与非公平锁

公平锁：锁的获取顺序必须和线程访问的先后顺序保持一致，就叫做公平锁
非公平锁：锁的获取顺序，和线程线程获取锁的前后顺序无关，就叫做非公平锁（默认锁策略）
非公平锁的优点：性能比较高。
公平锁优点：执行时有序的，所以结果也是可以预期的。

公平锁：new ReentrantLock(true)
非公平锁：new ReentrantLock()/new ReentrantLock(false)synchronized

自旋锁

自旋锁：通过死循环一直尝试获取锁。
缺点：如果发生死锁，则会一直循环，所以会带来一定的额外开销。

while(true){
    if(尝试获取锁) return;
}

可重入锁

可重入锁：当一个线程获取一个锁之后，可以重复进入。

public class ThreadDemoGJ8 {
    //创建锁
    private static Object lock = new Object();
    public static void main(String[] args) {
        synchronized (lock){
            System.out.println("第一次进入锁");
            synchronized (lock){
                System.out.println("第二次进入锁");
            }
        }
    }
}

在这里插入图片描述

宋丹尼尔
关注
专栏目录
【多线程】锁策略
程序猿教你打篮球的博客
07-05 4944
本期主要讲解： 1.说在前面 2.常见的锁策略 2.1乐观锁和悲观锁 2.2轻量级锁和重量级锁 2.3自旋锁和挂起等待锁 2.4互斥锁和读写锁 2.5公平锁和非公平锁 2.6可重入锁和不可重入锁
常见锁策略总结：从悲观锁到自旋锁
高耳机的博客
10-12 1607
在多线程编程的世界中，锁策略的选择对于确保数据一致性、提高系统性能以及优化资源利用至关重要。每种锁策略都有其独特的应用场景和性能考量。随着我们对这些锁策略的深入理解，我们可以更加精准地选择或设计适合特定应用需求的同步机制。这些策略都是我们在构建高效、稳定系统时的重要工具。
多线程--常见的锁策略总结
m0_58430482的博客
05-02 887
多线程--比较常见的锁策略--介绍了比较常见的锁。
常见锁策略
2302_77179144的博客
07-03 1030
读写锁就是把读操作和写操作分别进行加锁.读锁和读锁之间不互斥.写锁和写锁之间互斥.写锁和读锁之间互斥.读写锁最主要用在 “频繁读, 不频繁写” 的场景中.如果获取锁失败, 就会立即再尝试获取锁, 无限循环, 直到获取到锁为止. ⼀旦锁被其他线程释放, 就能第⼀时间获取到锁.优点: ⼀旦锁被释放就能第⼀时间获取到锁, 更高效. 在锁持有时间比较短的场景下非常有用.缺点: 如果锁的持有时间较长, 就会浪费 CPU 资源.
锁的分类总结
qq_38003038的博客
07-31 2047
可重入就是说某个线程已经获得某个锁，可以再次获取该锁。公平指的是按照线程请求的顺序，来分配锁；非公平指的是，不完全按照请求的顺序，在一定情况下，可以插队。注意非公平也同样不提倡“插队”行为，这里的非公平，指的是“在合适的时机”插队，而不是盲目插队。...
java锁总结
minipanda-luotj的博客
06-01 4623
之前做过一个测试，详情见这篇文章《多线程 +1操作的几种实现方式，及效率对比》，当时对这个测试结果很疑惑，反复执行过多次，发现结果是一样的: 1. 单线程下synchronized效率最高（当时感觉它的效率应该是最差才对）； 2. AtomicInteger效率最不稳定，不同并发情况下表现不一样：短时间低并发下，效率比synchronized高，有时甚至比LongAdder还高出一点，但是...
MySQL读写锁总结
csrxyr的博客
05-23 1780
读写锁 读锁：是一种共享锁，一个事务持有读锁时，不会阻塞其它的写锁，其他事务都可以对该数据进行读取； 写锁：是一种排他锁，一个锁持有写锁会阻塞其他的写锁和读锁，从而保证了一个只有一个事务进行写操作，并且防止其他事务读取正在写入资源，避免了脏读； 锁策略 锁策略：就是在锁的开销和数据安全性之间寻求平衡； 表锁：表锁是MySQL中最基本的锁策略，并且是开销最小的策略。表锁会锁定整张表，一个事务在...
面试必备之乐观锁与悲观锁
热门推荐
JavaGuide
07-16 30万+
悲观锁总是假设最坏的情况，认为共享资源每次被访问的时候就会出现问题(比如共享数据被修改)，所以每次在获取资源操作的时候都会上锁，这样其他线程想拿到这个资源就会阻塞直到锁被上一个持有者释放。也就是说，共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程。像 Java 中和等独占锁就是悲观锁思想的实现。悲观锁通常多用于写多比较多的情况下（多写场景），避免频繁失败和重试影响性能。
数据库锁分类和总结
weixin_39651041的博客
04-18 5万+
锁 锁是网络数据库中的一个非常重要的概念，当多个用户同时对数据库并发操作时，会带来数据不一致的问题，所以，锁主要用于多用户环境下保证数据库完整性和一致性。 帮助理解：以商场的试衣间为例，每个试衣间都可供多个消费者使用，因此，可能出现多个消费者同时需要使用试衣间试衣服。为了避免冲突，试衣间装了锁，某一个试衣服的人在试衣间里把锁锁住了，其他顾客就不能从外面打开了，只能等待里面的顾客试完衣服，...
【多线程】常见的锁策略
acm_pn的博客
09-18 1268
多线程之间，数据的读取⽅之间不会产⽣线程安全问题，但数据的写⼊⽅互相之间以及和读者之间都需要进⾏互斥。如果两种场景下都⽤同⼀个锁，就会产⽣极⼤的性能损耗。所以读写锁因此⽽产⽣。 读写锁（readers-writer lock），看英⽂可以顾名思义，在执⾏加锁操作时需要额外表明读写意图，重复读者之间并不互斥，⽽写者则要求与任何⼈互斥。 ⼀个线程对于数据的访问，主要存在两种操作：读数据 和 写数据.
Java锁的知识总结及实例代码共7页.pdf.zip
10-30
本资料"Java锁的知识总结及实例代码共7页.pdf.zip"详细介绍了Java锁的原理、类型以及实际应用，旨在帮助开发者深入理解并熟练运用Java锁机制。 在Java中，锁主要分为两类：内置锁（也称为监视器锁）和显式锁。内置...
锁机制学习与总结笔记参考
01-12
在计算机科学和编程领域，尤其是多线程编程中，锁机制是确保数据一致性与线程安全的关键工具。本文将深入探讨锁的原理、类型以及在实际应用中的使用方法。 一、锁的概述 锁机制是一种同步机制，用于控制对共享资源...
J2EE事务并发控制策略总结汇编.pdf
10-30
本文主要围绕J2EE环境下的持久层设计，特别是针对事务并发访问控制进行总结。事务并发访问控制分为两类：同一系统事务内的并发控制和跨系统事务的并发控制。在讨论具体策略之前，首先需要理解数据库事务的四种隔离...
电子商务之价格优化算法：梯度下降：机器学习在价格优化中的角色.docx
11-05
电子商务之价格优化算法：梯度下降：机器学习在价格优化中的角色.docx
ToadforOracle与Oracle数据库版本兼容性教程.docx
11-05
ToadforOracle与Oracle数据库版本兼容性教程.docx
browser360-cn-stable-13.3.1016.4-1-amd64.deb
11-05
360浏览器银河麒麟版 for X86 适配兆芯 / 海光 / intel / AMD CPU
基于React.js和Material-UI个人作品集网站模板（附源码+说明文档）.zip
11-05
使用React.js构建,提供多种主题可供选择,并且易于定制。该项目旨在帮助开发者和自由职业者创建自己的个性化投资组合。 主要功能点 多种主题可供选择,包括绿色、黑白、蓝色、红色、橙色、紫色、粉色和黄色 易于定制,可以在src/data文件夹中更新个人信息 包含主页、关于、简历、教育、技能、经验、项目、成就、服务、推荐信、博客和联系等多个部分 支持通过Google表单收集联系信息 提供SEO优化建议 支持多种部署方式,如Netlify、Firebase、Heroku和GitHub Pages 技术栈主要 React.js Material-UI Axios React-fast-marquee React-helmet React-icons React-reveal React-router-dom React-router-hash-link React-slick Slick-carousel Validator
中小型企业财务管理系统 SSM毕业设计 附带论文.zip
最新发布
11-05
中小型企业财务管理系统 SSM毕业设计 附带论文 启动教程:https://www.bilibili.com/video/BV1GK1iYyE2B
apsw-3.38.5.post1-cp39-cp39-win_amd64.whl.rar
11-05
python whl离线安装包 pip安装失败可以尝试使用whl离线安装包安装 第一步 下载whl文件，注意需要与python版本配套 python版本号、32位64位、arm或amd64均有区别 第二步 使用pip install XXXXX.whl 命令安装，如果whl路径不在cmd窗口当前目录下，需要带上路径 WHL文件是以Wheel格式保存的Python安装包， Wheel是Python发行版的标准内置包格式。 在本质上是一个压缩包，WHL文件中包含了Python安装的py文件和元数据，以及经过编译的pyd文件， 这样就使得它可以在不具备编译环境的条件下，安装适合自己python版本的库文件。 如果要查看WHL文件的内容，可以把.whl后缀名改成.zip，使用解压软件（如WinRAR、WinZIP）解压打开即可查看。 为什么会用到whl文件来安装python库文件呢？ 在python的使用过程中，我们免不了要经常通过pip来安装自己所需要的包， 大部分的包基本都能正常安装，但是总会遇到有那么一些包因为各种各样的问题导致安装不了的。 这时我们就可以通过尝试去Python安装包大全中（whl包下载）下载whl包来安装解决问题。
J2EE事务控制策略：乐观锁与悲观锁解析
"本文主要探讨了J2EE中的控制策略，特别是事务并发访问控制，包括乐观锁和悲观锁策略，并详细解释了它们的工作原理及在实际应用中的实施方式。" 在J2EE环境中，控制策略对于确保应用程序的稳定性和数据一致性至关...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

宋丹尼尔

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

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

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

打赏作者

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

抵扣说明：

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

余额充值