【Java编程的逻辑】原子变量 CAS 显示锁

2024-09-07 15:18
文章标签 java 显示 逻辑 编程 变量 原子 cas

本文主要是介绍【Java编程的逻辑】原子变量 CAS 显示锁，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

原子变量

在理解synchronized中有使用synchronized保证原子更新操作，但是使用synchronized成本太高了，需要先获取锁，最后还要释放锁，如果获取不到锁还需要等到。这些成本都是比较高的，对于这种情况，可以使用原子变量。
Java并发包中的基本原子变量类型有以下几种：

  • AtomicBoolean：原子Boolean类型，常用来在程序中表示一个标志位
  • AtomicInteger：原子Integer类型
  • AtomicLong：原子Long类型，常用来在程序中生成唯一序列号
  • AtomicReference：原子引用类型，用来以原子方式更新复杂类型

AtomicInteger

介绍

构造方法

// 给定一个初始值
public AtomicInteger(int initialValue) 
// 初始值为0
pubilc AtomicInteger()

它包含一些以原子方式实现组合操作的的方法 

// 以原子方式获取旧值并设置新值
public final int getAndSet(int newValue);
// 以原子方式获取旧值并给当前值加1 
public final int getAndIncrement();
// 以原子方式获取旧值并给当前值减1 
public final int getAndDecrement();
// 以原子方式获取旧值并给当前值加delta
public final int getAndAdd(int delta); 
// 以原子方式给当前值加1并获取新值
public final int incrementAndGet();
// 以原子方式给当前值减1并获取新值
public final int decrementAndGet();

这些方法的实现都依赖另一个public方法

public final boolean compareAndSet(int expect, int update);

compareAndSet方法，简称CAS。 该方法有两个参数expect和udpate，如果当前值等于expect，则更新为update，否则不更新，如果更新成功返回ture，否则返回false。这个操作都是原子性的。

AtomicInteger简单使用

public class AtomicIntegerDemo {private static AtomicInteger counter = new AtomicInteger();static class Visitor extends Thread {@Overridepublic void run() {for (int i = 0; i < 1000; i++) {counter.incrementAndGet();}}}public static void main(String[] args) throws InterruptedException {Thread[] threads = new Thread[100];for (int i = 0; i < threads.length; i++) {threads[i] = new Visitor();threads[i].start();threads[i].join();}System.out.println(counter.get());}
}

程序的输出总是正确的，为100000

AtomicInteger基本原理

AtomicInteger的大部分方法实现都类似，我们看一个方法:

public final int incrementAndGet() {for(;;) {int current = get();int next = current + 1;if(compareAndSet(current, next)) {return next;}}
}

代码是一个死循环，先获取当前值current，计算期望的值next，然后调用CAS方法进行更新，如果更新没有成功，说明value被别的线程改了，则再去取最新值并尝试更新直到成功

compareAndSet是怎么实现的呢？

public final boolean compareAndSet(int expect, int update) {return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}

unsafe的定义private static final Unsafe unsafe = Unsafe.getUnsafe(); 位于sun.misc包下。
原理上，一般的计算机系统都在硬件层次上直接支持CAS指令

与synchronized的比较

与synchronized锁相比，这种原子更新方式代表了一种不同的思维方式。
synchronized是悲观的，它假定更新很可能冲突，所以先获取锁，再进行更新。
原子变量的更新是乐观的，它假定冲突比较少，但是如果冲突了，就继续尝试更新。

synchronized是一种阻塞式算法，得不到锁的时候就进入等待队列，等待其他线程唤醒，有上下文切换的开销。
原子变量的更新是非阻塞式的。

实现锁

基于CAS，可以实现悲观阻塞式算法 

public class MyLock {private AtomicInteger status = new AtomicInteger(0);public void lock() {while(!status.compareAndSet(0, 1)) {Thread.yield();}}public void unlock() {status.compareAndSet(1, 0);}
}

显示锁

接口Lock

public interface Lock {// 获取锁void lock();// 获取锁，可以响应中断void lockInterrupteibly() throws InterruptedException;// 尝试获取锁，立即返回，不阻塞boolean tryLock();// 先尝试获取锁，如果能成功则立即返回true，否则阻塞等待，但等待的最长时间由参数设置，在等待的同时可以响应中断boolean tryLock(long time, TimeUnit unit) throws InterruptedException;// 释放锁void unlock();Condition newCondition();
}

相比于synchronized，显示锁支持以非阻塞方式获取锁，可以响应中断、可以限时，使得它灵活很多 。

可重入锁ReentrantLock

基本用法

Lock接口的主要实现类是ReentrantLock 

public ReentrantLock()  
public ReentrantLock(boolean fair)

参数fair表示是否保证公平，不指定的情况下，默认为false，表示不保证公平。所谓公平是指，等待时间最长的线程有限获得锁。保证公平会影响性能，一般也不需要

实现原理

ReentrantLock的实现依赖类LockSupport。
LockSupport也位于java.util.concurrent.locks下，它主要的方法如下 

// 使当前线程放弃CPU，进入WAITING状态
public static void park()
public static void parkNanos(long nanos)
public static void parkUntil(long deadline) 
public static void unpark(Thread thread)

park会使得当前线程放弃CPU，进行等待状态i，直到有其他线程对它调用了unpaark，unpark使参数指定的线程恢复可运行状态。
park不同于Thread.yield()， yield只是告诉操作系统可以先让其他线程运行，但自己依然是可以运行状态，而park会放弃调度资格，使线程进入WAITING状态

AQS

利用CAS和LockSupport提供的基本方法就可以实现ReentrantLock了。
Java提供了一个抽象类AbstractQueuedSynchronizer，简称AQS，简化并发工具的实现。
AQS封装了一个状态，给子类提供了查询和设置状态的方法

private volatile int state
protected final int getState()
protected final void setState(int newState)
protected final boolean compareAndSetState(int expect, int update)

用于实现锁时，AQS可以保存锁的当前持有线程，提供了方法进行查询和设置 

private transient Thread exclusiveOwnerThread;
protected final void setExclusiveOwnerThread(Thread t);
protected final Thread getExclusiveOwnerThread();

AQS内部维护了一个等待队列，借助CAS方法实现了无阻塞算法进行更新

ReentrantLock

ReentrantLock 内部使用了AQS，有三个内部类 

abstract static class Sync extends AbstractQueuedSynchronizer  
static final class NonfairSync extends Sync  
static final class FairSync extends Sync

NonfairSync是fair为false时使用的类，FairSync 是fair为true时使用的类。在ReentrantLock中有一个Sync变量，方法的具体调用都是通过它来的

我们先看lock的实现

public void lock() {sync.lock();
}

我们以默认的Nonfair类来进行分析

final void lock() {// 如果当前未被锁定，则立即获得锁if (compareAndSetState(0, 1))setExclusiveOwnerThread(Thread.currentThread());else// 获得锁acquire(1);
}

ReentrantLock用state来表示锁的状态
如果当前未被锁定，则立即获得锁，否则通过acquire(1)获得锁。
acquire(1)是AQS中的方法

// AbstractQueuedSynchronizer.java
public final void acquire(int arg) {if (!tryAcquire(arg) &&acquireQueued(addWaiter(Node.EXCLUSIVE), arg))selfInterrupt();
}

调用tryAcquire获取锁，tryAcquire必须被子类重写
NonfairSync实现如下：

// NonfairSync
protected final boolean tryAcquire(int acquires) {return nonfairTryAcquire(acquires);
}

nonfairTryAcquire是sync中实现：

// Sync
final boolean nonfairTryAcquire(int acquires) {final Thread current = Thread.currentThread();int c = getState();// 如果未被锁定，则使用CAS进行锁定if (c == 0) {if (compareAndSetState(0, acquires)) {setExclusiveOwnerThread(current);return true;}}// 如果已经被当前线程锁定，则增加锁定次数else if (current == getExclusiveOwnerThread()) {int nextc = c + acquires;if (nextc < 0) // overflowthrow new Error("Maximum lock count exceeded");setState(nextc);return true;}return false;
}

如果tryAcquire返回false，则AQS会调用：

// addWaiter会新建一个节点，代表当前线程，然后加入内部的等待队列中
acquireQueued(addWaiter(Node.EXCLUSIVE), arg);final boolean acquireQueued(final Node node, int arg) {boolean failed = true;try {boolean interrupted = false;for (;;) {final Node p = node.predecessor();// 检查当前节点是否是第一个等待的节点// 如果是，再判断是否能获取到锁if (p == head && tryAcquire(arg)) {setHead(node);p.next = null; // help GCfailed = false;return interrupted;}if (shouldParkAfterFailedAcquire(p, node) &&// 调用LockSupport.park放弃CPU，返回中断标志parkAndCheckInterrupt())interrupted = true;}} finally {if (failed)cancelAcquire(node);}
}

小结lock方法的基本过程：
1. 能获取锁就立即获得，否则加入等待队列
2. 被唤醒后检查自己是否是第一个等待的线程，如果是且能获得锁则返回。否则继续等待
3. 在这个过程中，如果发生了中断，lock会记录中断标志位，但不会提前返回或抛出异常

unlock的实现主要是修改状态释放锁。
不过FairSync和NonfairSync的区别是：在获取锁时，FairSync多了一个检测，只有不存在其他等待时间更长的线程，它才会获取锁。

保证公平整体性能比较低，低的原因不是这里多了一个检查，而是会让活跃线程得不到锁，进入等待状态，引起频繁上下文切换，降低了整体的效率

显示条件

锁用于解决竞态条件问题，条件是线程间的协作机制。
wait/notify与synchronized配合使用， 显示条件与显示锁配合使用。

Condition 表示条件变量，是一个接口 

public interface Condition { void await() throws InterruptedException;void awaitUninterruptibly();long awaitNanos(long nanosTimeout) throws InterruptedException;boolean await(long time, TimeUnit unit) throws InterruptedException;boolean awaitUntil(Date deadline) throws InterruptedException;  void signal();void signalAll();
}

await对应于Object的wait，signal对应于notify，signalAll对应于notifyAll
调用await方法前需要先获取锁。await在进入等待队列后，会释放锁，释放CPU，当其他线程将它唤醒后，或等待超时后，或发生中断异常后，它都需要重新获取锁，获取锁后，才会从await方法中退出

这篇关于【Java编程的逻辑】原子变量 CAS 显示锁的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1145418。

相关文章

Java中流式并行操作parallelStream的原理和使用方法

Java中流式并行操作parallelStream的原理和使用方法

《Java中流式并行操作parallelStream的原理和使用方法》本文详细介绍了Java中的并行流（parallelStream）的原理、正确使用方法以及在实际业务中的应用案例,并指出在使用并行流... 目录Java中流式并行操作parallelStream0. 问题的产生1. 什么是parallelS
阅读更多...
Java中Redisson 的原理深度解析

Java中Redisson 的原理深度解析

《Java中Redisson的原理深度解析》Redisson是一个高性能的Redis客户端,它通过将Redis数据结构映射为Java对象和分布式对象,实现了在Java应用中方便地使用Redis,本文... 目录前言一、核心设计理念二、核心架构与通信层1. 基于 Netty 的异步非阻塞通信2. 编解码器三、
阅读更多...
SpringBoot基于注解实现数据库字段回填的完整方案

SpringBoot基于注解实现数据库字段回填的完整方案

《SpringBoot基于注解实现数据库字段回填的完整方案》这篇文章主要为大家详细介绍了SpringBoot如何基于注解实现数据库字段回填的相关方法,文中的示例代码讲解详细,感兴趣的小伙伴可以了解... 目录数据库表pom.XMLRelationFieldRelationFieldMapping基础的一些代
阅读更多...
一篇文章彻底搞懂macOS如何决定java环境

一篇文章彻底搞懂macOS如何决定java环境

《一篇文章彻底搞懂macOS如何决定java环境》MacOS作为一个功能强大的操作系统,为开发者提供了丰富的开发工具和框架,下面：本文主要介绍macOS如何决定java环境的相关资料,文中通过代码... 目录方法一：使用 which命令方法二：使用 Java_home工具（Apple 官方推荐）那问题来了，
阅读更多...
Java HashMap的底层实现原理深度解析

Java HashMap的底层实现原理深度解析

《JavaHashMap的底层实现原理深度解析》HashMap基于数组+链表+红黑树结构,通过哈希算法和扩容机制优化性能,负载因子与树化阈值平衡效率,是Java开发必备的高效数据结构,本文给大家介绍... 目录一、概述：HashMap的宏观结构二、核心数据结构解析1. 数组（桶数组）2. 链表节点（Node
阅读更多...
Java AOP面向切面编程的概念和实现方式

Java AOP面向切面编程的概念和实现方式

《JavaAOP面向切面编程的概念和实现方式》AOP是面向切面编程,通过动态代理将横切关注点（如日志、事务）与核心业务逻辑分离,提升代码复用性和可维护性,本文给大家介绍JavaAOP面向切面编程的概... 目录一、AOP 是什么？二、AOP 的核心概念与实现方式核心概念实现方式三、Spring AOP 的关
阅读更多...
详解SpringBoot+Ehcache使用示例

详解SpringBoot+Ehcache使用示例

《详解SpringBoot+Ehcache使用示例》本文介绍了SpringBoot中配置Ehcache、自定义get/set方式,并实际使用缓存的过程,文中通过示例代码介绍的非常详细,对大家的学习或者... 目录摘要概念内存与磁盘持久化存储：配置灵活性：编码示例引入依赖：配置ehcache.XML文件：配置
阅读更多...
Java 虚拟线程的创建与使用深度解析

Java 虚拟线程的创建与使用深度解析

《Java虚拟线程的创建与使用深度解析》虚拟线程是Java19中以预览特性形式引入,Java21起正式发布的轻量级线程,本文给大家介绍Java虚拟线程的创建与使用,感兴趣的朋友一起看看吧... 目录一、虚拟线程简介1.1 什么是虚拟线程？1.2 为什么需要虚拟线程？二、虚拟线程与平台线程对比代码对比示例：三
阅读更多...
Java中的.close()举例详解

Java中的.close()举例详解

《Java中的.close()举例详解》.close()方法只适用于通过window.open()打开的弹出窗口,对于浏览器的主窗口,如果没有得到用户允许是不能关闭的,：本文主要介绍Java中的.... 目录当你遇到以下三种情况时，一定要记得使用 .close()：用法作用举例如何判断代码中的 input
阅读更多...
Spring Gateway动态路由实现方案

Spring Gateway动态路由实现方案

《SpringGateway动态路由实现方案》本文主要介绍了SpringGateway动态路由实现方案,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随... 目录前沿何为路由RouteDefinitionRouteLocator工作流程动态路由实现尾巴前沿S
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2