Java并发编程 —— 锁策略

最新推荐文章于 2023-05-12 17:09:27 发布
最新推荐文章于 2023-05-12 17:09:27 发布
阅读量241 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MercuryG/article/details/118014881
版权
乐观锁
  • 认为一般情况西不会发生冲突，只有在进行数据更新的时候，才会检测并发冲突，如果没有冲突则执行修改，如果有冲突则返回修改。
  • CAS（乐观锁的具体实现）Compare And Swap —— 比较并且交换
    CAS中的三个组成部分：
    V（内存值）、A（旧值）、B（新值）
    实现原理：
    V == A？true（没有并发冲突） —> V = B
        false（并发冲突） —> 该线程将旧值A修改为此时内存中的V值，然后再进行一次比较
  • 乐观锁的事项 Atomic*
    Atomic*（乐观锁的实现）也可以解决线程不安全的问题
package LockStrategy;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * 使用Atomic类解决线程不安全问题
 * **/
public class ThreadDemo90 {
    private  static  AtomicInteger count = new AtomicInteger(0);
    private  static  final  int MAXSEIZ = 100000;
    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < MAXSEIZ; i++) {
                    count.getAndIncrement();
                }
            }
        });
        t1.start();
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < MAXSEIZ; i++) {
                    count.getAndDecrement();
                }
            }
        });
        t2.start();
        t1.join();
        t2.join();
        System.out.println("最终结果为：" + count);

    }
//    public static void main(String[] args) {
//        AtomicInteger count = new AtomicInteger(0);
//        count.getAndIncrement(); // i++
//        count.incrementAndGet(); // ++i
//    }
}

  • 问：CAS的底层实现原理是什么？
    答：Java 层面 CAS 的原理是 UnSafe 类，UnSafe 调用了 C++ 的本地方法，通过调用操作系统的 Atomic::cmpxchg（原子指令）来实现CAS操作（底层方法是native修饰的）

  • 乐观锁性能比较高

  • CAS 的缺点：
    CAS 存在 ABA 问题 —> AtomicInteger 是存在 ABA 问题的
    A表示预期旧值，B表示新值
    举例（银行转账）：
      甲给乙转账100块钱，点击了两次提交，如下图，这样有100块钱就消失了
    在这里插入图片描述

  • 上述问题代码实现

package LockStrategy;
import java.util.concurrent.atomic.AtomicReference;
/**
 * ABA 问题演示（转账示例）
 * **/
public class ThreadDemo91 {
    private static AtomicReference money =
            new AtomicReference(100); // 初始化余额为100

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

        // 转账线程1  -100
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // AtomicReference 自带的比较并修改方法
                boolean result = money.weakCompareAndSet(100,0);  // 这就是一个转账操作
                System.out.println("第一次转账是否成功：" + result);
            }
        });
        t1.start();
        t1.join();
        // 转入100 元
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                boolean result = money.compareAndSet(0,100);
                System.out.println("转入100元：" + result);
            }
        });
        t3.start();
        t3.join();
        // 转账线程2  -100
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                // AtomicReference 自带的比较并修改方法
                boolean result = money.weakCompareAndSet(100,0);  // 这就是一个转账操作
                System.out.println("第二次转账是否成功：" + result);
            }
        });
        t2.start();
    }
}
  • 如何解决改ABA问题？
    引入版本号，每次在修改之后跟新版本号，使用AtomicStampedReference
package LockStrategy;

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

/**
 * 使用 AtomicStampedReference 解决ABA问题 
 *  核心： 多了一个版本号
 * **/

public class ThreadDemo92 {
    private static AtomicStampedReference money =
            new AtomicStampedReference(100,1);
//    private static AtomicReference money =
//            new AtomicReference(100); // 初始化余额为100

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

        // 转账线程1  -100
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // AtomicReference 自带的比较并修改方法
                // 四个参数 ： 旧值 、 预期新值、 旧版本号 、 新版本号
                boolean result = money.weakCompareAndSet(100,0,1,2);  // 这就是一个转账操作
                System.out.println("第一次转账是否成功：" + result);
            }
        });
        t1.start();
        t1.join();
        // 转入100 元
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                boolean result = money.compareAndSet(0,100,2,3);
                System.out.println("转入100元：" + result);
            }
        });
        t3.start();
        t3.join();
        // 转账线程2  -100
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                // AtomicReference 自带的比较并修改方法
                boolean result = money.weakCompareAndSet(100,0,1,2);  // 这就是一个转账操作
                System.out.println("第二次转账是否成功：" + result);
            }
        });
        t2.start();
    }
}
  • 如果将转账的金额全部求改为1000，运行后发现全是false
    这是由于Integer 的高速缓存范围为 -128 ~ 127 ，若不在这个范围内，就会new一个新的对象
    想要解决这个问题，修改JVM的缓存就可，在IDEA的Run/Debug Configurations中修改VM optins为-Djava.lang.Integer.IntegerCache.high=1000 ，这段的意思就是设置高速缓存的最大值
悲观锁
  • 认为通常情况下会出现并发冲突，所以在一开始就会加锁
    例如 synchronized
共享锁/非共享锁（独占锁）

  • 共享锁：一把锁可以被多个线程拥有，叫做共享锁。
    读写锁中的读锁就是共享锁
    读写锁：就是将一个锁分为两个，一个用于读数据的锁（也叫做读锁），另一把锁叫做写锁，读锁是可以被多个线程同时拥有的，而写锁则只能被一个线程拥有
    ReentrantReaderWriterLock()
    读写锁的优势：锁的粒度更加的小，性能也更高

  • 非共享锁：一把锁只能被一个线程拥有，叫做非共享锁。synchronized

  • 代码实现读写锁：

package LockStrategy;

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

public class ThreadDemo96 {

    public static void main(String[] args) {
        // 创建一个读写锁
        ReentrantReadWriteLock readWriteLock =
                new ReentrantReadWriteLock();// true 表示为公平锁，默认为false

        // 读锁
        ReentrantReadWriteLock.ReadLock readLock =
                readWriteLock.readLock();

        // 写锁
        ReentrantReadWriteLock.WriteLock writeLock =
                readWriteLock.writeLock();

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

        // 任务1：执行读锁
        executor.execute(new Runnable() {
            @Override
            public void run() {
                // 加锁
                readLock.lock();
                try {
                    // 业务逻辑处理
                    System.out.println("线程名："+ Thread.currentThread().getName() +
                            "执行了读锁操作：" + new Date());
                    try {
                        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());
                    try {
                        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;
	}
}
可重入锁
  • 当一个线程获取了一个锁之后，可以重复的进入
package LockStrategy;
/**
 * 演示可重入锁
 * **/
public class ThreadDemo97 {
    // 创建锁
    private static Object lock = new Object();

    public static void main(String[] args) {
        // 第一次进入锁
        synchronized (lock){
            System.out.println("第一次进入锁");
            synchronized (lock){
                System.out.println("第二次进入锁");
            }
        }
    }

}
总结：
  • 问：你是怎么理解乐观锁和悲观锁的，具体是怎么实现的？
    答：乐观锁认为通常情况下不会出现并发冲突，所以只有在提交数据的时候才会检测是否有冲突；悲观锁认为事情总是发生在最坏的情况，所以每次在第一次进入之后都叫进行加所操作
    具体实现：
    1、乐观锁的实现为： 有一种实现机制为 CAS(比较并替换)，CAS在JAVA中的具体实现是 Atomic家族。CAS 是由 V（内存中值）、 A（预期旧值、B（预期新值）三个组成，在执行的时候，使用V和A进行对比，如果结果为 true 这表明没有并发冲突，则可以直接修改，否则不能修改。 CAS 使用过调用C++ 提供的 UnSafe 中的本地方法(CompareAndSwapXXX)来实现。C++是通过调用操作系统的Atomic::cmpxchg（原子指令）来实现的
    2、悲观锁的实现为：synchronized 在Java中是将锁的的 ID 存放到对象头来实现，synchronized 在 JVM 层面是通过监视锁来实现，synchronized 在操作系统层面是通过互斥锁 mutex 实现
  • 问：你是否了解读写锁？
    答：读写锁是将锁的粒度分的更细了，分为读操作和写操作，并且读操作和写操作之间是互斥的，互斥的原因是为了防止出现脏数据（脏读）。读锁是可以多个线程共同拥有的，所以可以是共享锁；写锁是独占锁，在一个线程操作的时候其他线程不能操作。读写锁在java中使用ReentrantReadWriteLock创建，通过readWriteLock.readLock()和readWriteLock.writeLock()分别得到读锁和写锁
  • 问：什么叫做自旋锁，自旋锁的缺点是什么？
    答：自旋锁就是通过死循环一直尝试去获取锁。自旋锁的缺点是，如果发生死锁，则会一直自旋(循环)，会带来额外的开销。java中通过对对自旋增加明确的次数，当自旋次数大于规定次数还没有获取到锁，那就将它放到锁的等待队列中，等待有锁的时候再去唤醒它
MercuryG
关注
多线程常见锁的策略
m0_68989458的博客
07-04 488
多线程常见的锁的策略小结
Java并发编程进阶——并发锁
行者无疆的博客
03-14 4289
1 JAVA 多线程锁介绍 1.1 悲观锁 定义：悲观锁指对数据被外界修改持保守态度，认为数据很容易就会被其他线程修改（很悲观），所以在数据被处理前先对数据进行加锁，并在整个数据处理过程中，使数据处于锁定状态。 悲观锁的实现：开发中常见的悲观锁实现往往依靠数据库提供的锁机制，即在数据库中，在对数据记录操作前给记录加排它锁。如果获取锁失败，则说明数据正在被其他线程修改，当前线程则等待或者抛出异常。如果获取锁成功，则对记录进行操作，然后提交事务后释放排它锁。 实例：Java 中的 synchronized 关键
并发编程中常见的锁策略＜包含详细介绍CAS机制和ABA问题＞
weixin_46448719的博客
04-20 2223
常见锁策略 乐观锁与悲观锁 <CAS机制的ABA问题> 公平锁与非公平锁 独占锁与共享锁<锁一直是围绕线程安全来实现的> 可重入锁 自旋锁
从Java并发集合看锁优化策略
weixin_34452850的博客
11-24 1010
1.ConcurrentHashMapConcurrentHashMap是支持并发的HashMap类，可以在多线程环境下保证线程安全。ConcurrentHashMap的核心思想就是减小锁的粒度。传统的线程安全的Hashtable在同步时采用了synchronized关键字，所有对Hashtable的读写操作都要先获取对象锁，在锁竞争比较激烈的情况下会导致性能很低。ConcurrentHashMap
Mysql的并发（锁策略、锁粒度、事务）
qq_40093255的博客
09-04 452
并发控制  在处理并发读或者写时，可以通过实现一个由两种类型的锁组成的锁系统来解决问题。这俩种系统的锁通常被称为共享锁（shared lock）和排他锁(exclusive lock),也叫读锁（read lock）和写锁（write lock）。  读锁是共享的，或者说是相互不阻塞的。多个客户在同一时刻可以同时读取同一个资源，而互不干扰。写锁时排他的，也就是说一个写锁会阻塞其他的写锁和读锁，这是...
Java CAS底层原理
Lailai Monkey的博客
11-16 5854
Java CAS底层原理 Java CAS底层原理，这一篇就够了！！！ CAS全称（Conmpare And Swap）比较并交换，是一种用于在多线程环境下实现同步功能的机制。CAS 操作包含三个操作数 – 内存地址、预期值和新值。CAS 的实现逻辑是将内存地址的数值与预期数值想比较，若相等，则将内存位置处的值替换为新值。若不相等，则不做任何操作。 JAVA中CAS是通过自旋操作完成赋值，若值不相...
java并发编程——内存模型
02-24
并发——在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行，但任一个时刻点上只有一个程序在处理机上运行——源自百度百科在并发编程中，我们需要...
深入理解Java并发编程——基石篇精华总结
这篇PDF文档是关于Java并发编程的基石篇，作者在知乎上发布过相关文章，但为了更好的阅读体验和无字数限制，整理成了PDF格式。文档涵盖了Java并发的基础知识，包括线程、同步机制、对象监控以及volatile关键字的使用...
Java并发编程总结——慎用CAS详解
09-02
Java并发编程中，CAS（Compare and Swap，比较并交换）是一种无锁算法，常用于实现原子操作，它在多线程环境下提供了数据的一致性。然而，CAS并不是万能的，过度依赖或不当使用可能会导致问题。下面我们将深入探讨...
【分布式事务】Seata 之 @GlobalLock 是AT模式下隔离性保障神器之一
最新发布
DreamSun的博客
05-12 1409
Seata AT模式下，如果服务A(服务接口或方法)参与全局事务，即在全局事务中作为一个分支事务，那么会在 TC 侧添加行锁记录，用于保障全局事务的隔离性。但还有另外一种情况，如果某个服务B从调用上下文上看，并未与其他服务一起协作，而是一个独立的逻辑，但与其他参与全局事务的服务都操控表C中的记录；这种情况下如没有处理好隔离性，会导致服务A无法完成二阶段回滚；如服务A在参与全局事务在一阶段修改了表C中的D记录，服务B也修改了表C中的D记录。
Java CAS底层实现原理实例详解
08-25
主要介绍了Java CAS底层实现原理实例详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
随笔20 java中锁的种类及分析
weixin_30641465的博客
11-13 97
http://www.importnew.com/19472.html 一：java中的锁 java中各种锁的概念包括：公平锁、非公平锁、自旋锁、可重入锁、偏向锁、轻量级锁、重量级锁、读写锁、互斥锁等待。 公平锁和非公平锁 公平锁是指多个线程在等待同一个锁时，必须按照申请锁的先后顺序来一次获得锁。 公平锁的好处是等待锁的线程不会饿死，但是整体效率相对低一些； 非公平锁的好处是整...
Java CAS底层实现原理和延伸思考
刘政良
05-31 319
问题抛出 CAS底层实现原理 高并发情况下存在ABA问题以及如何解决 JAVA内存模型ABA变化 延伸思考 和synchronized,lock的区别，以及synchronized锁优化的过程 高并发环境下用cas还是synchronized这是个坑 synchronized关键字保证同步的，这会导致有锁。 锁机制存在以下问题： （1）在多线程竞争下，加锁、释放锁会导致比较多的上下文切换和调度延时，引起性能问题。 （2）一个线程持有锁会导致其它所有需要此锁的线程挂起。 （3）如果一个优先级高的线程
java---CAS原理分析详解
m0_58196614的博客
08-22 2430
CAS的全称为Compare-And-Swap,它是一条CPU同步原语，是一种硬件对并发的支持。它的功能是判断内存某个位置的值是否为预期值,如果是则更新为新的值，这个过程是原子的
JAVA CAS 底层原理详解
Etwases的博客
05-16 1651
CAS CAS是指Compare And Swap，比较并交换，是一种很重要的同步思想。如果主内存的值跟期望值一样，那么就进行修改，否则一直重试，直到一致为止。 public class CASDemo { public static void main(String[] args) { AtomicInteger atomicInteger=new AtomicInteger(5); System.out.println(atomicInteger.compareA
Java CAS原理和底层源码实现
天道酬勤
03-06 3024
一、CAS 1、简介 cas CAS 的意思是 compare and swap，比较并交换。 CAS 的示意图如下： 比如一个很简单的操作，把变量 A = 2 加 1，结果为 3. 则先读取 A 的当前值 E 为 2，在内存计算结果 V 为 3，比较之前读出来的 A 的当前值 2 和 最新值，如果最新值为 2 ，表示这个值没有被别人改过，则放心的把最终的值更新为 3. 有一种情况是，在你更新结果之前，其他有个线程在中途把 A 更新成了 5 ，又更新回了 2。但是在当前线程看起来，没有被改过。这就是 A
Java并发编程之CAS底层实现原理
Carson.zhao-blog
07-07 317
什么是CAS？ CAS的全称是Compare-And-Swap（乐观锁的内部实现） 功能：用于判断内存某个位置的Value值是否为预期值A，如果是则更改为新的值B，整个操作过程是原子操作 使用场景： CAS体现在Java语言中就是sun.misc.Unsafe类的各个方法 调用UnSafe类中的CAS方法，JVM会帮我们实现出CAS汇编指令，是完全依赖于硬件的功能，由于CAS是一种系统原语，原语属于操作系统使用范畴，是由若干条指令组成，用于完成某个功能的一个过程，并且原语的执行必须是连续的，在执行过
Java CAS无锁技术深度解析
拈花的专栏
10-17 1920
在看AQS代码的时候，看到它很多地方调用了unsafe.compareAndSwapInt这类方法，百度了一下得知这叫CAS无锁技术。 CAS原理深度分析 转自：https://blog.csdn.net/Hsuxu/article/details/9467651?utm_source=blogxgwz1。 CAS: Compare and Swap，翻译成比较并交换。 java.uti...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值