1.CAS原理
1.1 CAS的工作原理
CAS，即Compare-And-Swap或比较并交换，是实现并发算法时常用的一种机制。它涉及三个操作数——内存位置V（Variable），预期原值A（Anticipated value），以及新值B（New value）。其基本操作是：当且仅当V的值等于A时，CAS才会通过原子方式用新值B来更新V的值，否则不进行任何操作。让我们通过代码示例进一步理解CAS机制：
import java.util.concurrent.atomic.AtomicInteger;
class CASExample {
private AtomicInteger count = new AtomicInteger(0);
public void increment() {
int expect;
do {
expect = count.get(); // 获取当前值
// 此处可能会有多个线程尝试更新同一个count
} while (!count.compareAndSet(expect, expect + 1)); // CAS操作
}
public int getCount() {
return count.get();
}
}
1.2 锁自旋与性能优化
传统的阻塞锁在等待锁的过程中会使线程进入睡眠，这会导致线程上下文切换，带来额外的开销。因此，引入了一种轻量级的锁机制——锁自旋。它通过不断循环等待（自旋），检查锁的状态，以尝试获取锁。这种方式在多核处理器上，如果等待时间不长的话，能够减少线程状态变更的开销，提高系统整体性能。例如，在JDK中，可以通过-XX:+UseSpinning启用自旋锁。
1.3 Java在CAS上的实现实践
Java从1.5开始引入了java.util.concurrent.atomic包，它提供了一组利用CAS操作进行锁自旋的工具类，例如AtomicInteger，AtomicLong，AtomicReference等。这些类可以帮助开发人员以线程安全的方式操作单个变量，而无需使用synchronized关键字。
import java.util.concurrent.atomic.AtomicReference;
public class AtomicReferenceDemo {
public static void main(String[] args) {
AtomicReference<String> atomicString = new AtomicReference<>("Initial Value");
String previousValue = atomicString.getAndSet("New Value");
System.out.println("Previous Value: " + previousValue);
System.out.println("Current Value: " + atomicString.get());
}
}
2.CAS在并发编程中的应用
2.1 在并发容器中的使用案例
让我们看一个例子，其中CAS用于实现非阻塞的并发容器。如ConcurrentLinkedQueue，一个基于链接节点的无界线程安全队列，内部正是使用CAS来达到线程安全的。
import java.util.concurrent.ConcurrentLinkedQueue;
public class ConcurrentLinkedQueueExample {
public static void main(String[] args) {
ConcurrentLinkedQueue<Integer> queue = new ConcurrentLinkedQueue<>();
queue.offer(1); // 将特定元素插入到此队列的尾部。
queue.offer(2);
System.out.println(queue.poll()); // 返回队列头部的元素，并从队列中移除
System.out.println(queue.poll());
}
}
2.2 从基本类型到数组和引用类型的原子操作
除了对基本数据类型的支持，atomic包还提供了数组和对象属性的原子更新器。AtomicIntegerFieldUpdater和AtomicReferenceArray是这类原子更新器的两个例子。
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
class AtomicUpdaterExample {
private static class Candidate {
volatile int score;
}
private static final AtomicIntegerFieldUpdater<Candidate> scoreUpdater =
AtomicIntegerFieldUpdater.newUpdater(Candidate.class, "score");
public static void main(String[] args) {
Candidate candidate = new Candidate();
scoreUpdater.incrementAndGet(candidate); // score以原子方式加1
System.out.println(candidate.score); // 打印更新后的值
}
}
2.3 如何避免竞争：高级编程技巧
在多线程环境下，避免资源竞争是关键。例如，我们可以将热点数据分散在多个变量中，利用Striped64类（如LongAdder的内部实现）分散竞争，这可以大幅度提升性能。
3.详解ABA问题
3.1 ABA问题的产生与解释
在CAS操作中存在着一个著名的ABA问题，其发生在这样一种情况：一个线程读取某内存位置的值A，并在此后的某个时间点比较并交换，期待内存位置仍然是A值。在此期间，即使该位置的值可能已被其他线程改为B，然后又改回A，当前线程的CAS操作仍然会成功。虽然“看起来”没有问题，但是中间的变化可能导致系统的不一致性，这种情况在某些算法中可能是灾难性的。 为了解决此问题，我们可以使用现代CPU提供的更复杂的CAS变体，例如LL/SC（Load-Link/Store-Conditional）或者添加一个版本号用于验证。
3.2 如何检测并避免ABA问题
在Java中，一个常用的避免ABA问题的解决方案是使用带有版本号的原子引用，即AtomicStampedReference类。它持有一个对象引用以及一个时间戳或者“版本号”，通过版本号来确保在进行比较并交换时，数据没有被意外更改过。
import java.util.concurrent.atomic.AtomicStampedReference;
public class AtomicStampedReferenceDemo {
public static void main(String[] args) {
String initialRef = "initial value referenced";
int initialStamp = 0;
AtomicStampedReference<String> atomicStampedRef =
new AtomicStampedReference<>(initialRef, initialStamp);
String newRef = "new value referenced";
int newStamp = initialStamp + 1;
boolean exchanged = atomicStampedRef.compareAndSet(
initialRef, newRef, initialStamp, newStamp);
System.out.println("Exchanged: " + exchanged); // true
exchanged = atomicStampedRef.compareAndSet(
initialRef, "another value", newStamp, newStamp + 1);
System.out.println("Exchanged: " + exchanged); // false
}
}
3.3 解决方案：原子标记或版本机制的实践
AtomicMarkableReference是另一个解决ABA问题的工具，它包含一个布尔标记，用来表示当前引用是否被修改过，这就允许系统在进行原子操作时检查除了数值以外的额外信息。
4.AQS框架介绍
4.1 AQS的设计原理与组件结构
AbstractQueuedSynchronizer（AQS）是实现依赖于先进先出（FIFO）等待队列的同步器的框架。它为多个同步器提供了一个可重用的基础，如ReentrantLock、Semaphores、CountDownLatch等。AQS使用一个int类型的成员变量表示同步状态（state），并通过内置的FIFO队列来管理线程。 AQS的主要组件包括：
- 同步状态（State）：表示资源的占用情况。
- 节点（Node）：构成等待队列，存储线程信息。
- 内置FIFO队列：管理因获取状态失败而等待的线程。
同步器的实现基于模板方法模式，AQS定义了一系列需要子类去实现的方法，例如tryAcquire、tryRelease等，用于资源的独占访问。
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
class Mutex {
// 自定义同步器
private static class Sync extends AbstractQueuedSynchronizer {
// 判断是否已经被占有
protected boolean isHeldExclusively() {
return getState() == 1;
}
// 尝试获取资源，立即返回。成功则返回true，否则false。
public boolean tryAcquire(int acquires) {
assert acquires == 1; // Otherwise unused
if (compareAndSetState(0, 1)) {
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}
// 尝试释放资源，立即返回。成功则返回true，否则false。
protected boolean tryRelease(int releases) {
assert releases == 1; // Otherwise unused
if (getState() == 0) throw new IllegalMonitorStateException();
setExclusiveOwnerThread(null);
setState(0);
return true;
}
}
private final Sync sync = new Sync();
// 加锁操作，调用同步器模板方法
public void lock() {
sync.acquire(1);
}
// 释放锁操作，调用同步器模板方法
public void unlock() {
sync.release(1);
}
}
4.Exclusive和Share模式
4.1 独占模式下的同步器实现：ReentrantLock
独占模式是指某一时刻只有一个线程能够获取同步状态，如ReentrantLock。它是基于AQS的一个典型例子，提供了可重入的锁功能。其内部类Sync继承自AbstractQueuedSynchronizer，并实现了获取和释放锁的机制。
import java.util.concurrent.locks.ReentrantLock;
public class ReentrantLockExample {
private final ReentrantLock lock = new ReentrantLock();
public void performTask() {
lock.lock(); // 独占地获取锁
try {
// Access the resource protected by this lock
} finally {
lock.unlock(); // 释放锁
}
}
}
4.2 共享模式的工作机制：Semaphore与CountDownLatch
与独占模式不同，共享模式允许多个线程同时获取同步状态。例如，Semaphore用来控制同时访问某个特定资源的操作数量，而CountDownLatch允许一个或多个线程等待其他线程完成操作。
import java.util.concurrent.Semaphore;
public class SemaphoreExample {
private final Semaphore semaphore = new Semaphore(10); // 允许10个线程同时访问
public void doSomething() {
try {
semaphore.acquire();
// Access the shared resource
} finally {
semaphore.release();
}
}
}
import java.util.concurrent.CountDownLatch;
public class CountDownLatchExample {
private static final int COUNT = 3;
private final CountDownLatch latch = new CountDownLatch(COUNT);
public void performTask() {
new Thread(() -> {
// Perform some operation
latch.countDown();
}).start();
// Wait on the latch
latch.await();
// Continue with the processing
}
}
4.3 如何平衡独占与共享：ReentrantReadWriteLock的内部机制
ReentrantReadWriteLock采用了AQS框架，将锁的状态分为读状态和写状态，可以允许多个线程同时进行读操作，而写操作则是独占的。这样可以提高程序在高读取率时的性能。
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class ReentrantReadWriteLockExample {
private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
public void readResource() {
rwLock.readLock(
//lock();
try {
// Perform read operations - Multiple threads can read at once
} finally {
rwLock.readLock().unlock(); // Unlock read
}
}
public void writeResource() {
rwLock.writeLock().lock(); // Only one thread can write at a time
try {
// Perform write operations
} finally {
rwLock.writeLock().unlock(); // Unlock write
}
}
}
这种读写锁允许在没有任何写入器时尽可能多的读取器，并且在写入时提供独占访问。
5.AQS在实际编程中的应用
5.1 实际案例：使用AQS构建自定义同步组件
AQS为实现自定义的同步组件提供了强大的基础。通过继承AbstractQueuedSynchronizer并实现必要的方法，开发者可以创建符合特定需求的锁和其他同步器。以下是构建一个简单的自定义锁的例子：
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
public class ExclusiveLock {
private static class Sync extends AbstractQueuedSynchronizer {
@Override
protected boolean tryAcquire(int arg) {
if (compareAndSetState(0, 1)) {
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}
@Override
protected boolean tryRelease(int arg) {
if (getState() == 0 || getExclusiveOwnerThread() != Thread.currentThread()) {
throw new IllegalMonitorStateException();
}
setExclusiveOwnerThread(null);
setState(0);
return true;
}
public boolean isLocked() {
return getState() != 0;
}
}
private final Sync sync = new Sync();
public void lock() {
sync.acquire(1);
}
public void unlock() {
sync.release(1);
}
public boolean isLocked() {
return sync.isLocked();
}
}
5.2 高级特性：公平性、线程中断与超时控制
AQS支持公平锁和非公平锁，公平锁按等待时间长短来获取锁，而非公平锁则可能“插队”。此外，AQS能够响应中断，比如当线程获取锁时可以对中断做出响应。同时还可以实现尝试在指定的时间内获取锁，超时则放弃，这对于避免死锁很有用。
5.3 性能优化：减少锁竞争的策略与实践
了解不同类型的锁及其适用情况可以显著提升性能。例如，读多写少的情况下，ReentrantReadWriteLock比ReentrantLock更加适用。另外，减小锁的粒度，使用分段锁（如ConcurrentHashMap中的实现）等也是减少锁竞争、提升并发性能的优秀策略。
6.结合CAS与AQS：并发工具的组合
6.1 怎样结合CAS和AQS设计高效同步器
高效的同步器设计需要了解CAS和AQS的底层机制及其交互方式。在设计同步器时，CAS通常用于状态的操作，而AQS负责线程的排队和阻塞。结合起来，我们可以设计出既快速又可靠的高性能同步器。例如，ReentrantLock就是一个结合了CAS操作（快速路径）和AQS队列（慢路径）的锁实现。如果一个线程尝试获取锁而锁不可用，在尝试了若干次CAS操作失败后，线程就会被放入AQS队列中排队等待。
import java.util.concurrent.locks.ReentrantLock;
public class ReentrantLockUsage {
private final ReentrantLock lock = new ReentrantLock();
public void sharedMethod() {
lock.lock(); // CAS尝试获取锁
try {
// 如果获取成功，则执行同步代码
} finally {
lock.unlock(); // 释放锁
}
}
}
6.2 现代并发框架中的应用案例分析
6.2.1 Akka中的Actor模型与无锁并发
Akka框架基于Actor模型来实现其并发机制。在Actor模型中，每个Actor是一个并发单元，与其它的Actor通过消息传递进行交互，而不是通过共享内存。这种模型避免了传统多线程同步问题。Akka内部为了保持高性能和低延迟，大量使用无锁并发，特别利用CAS操作来管理Actor之间的状态变化。 例如，Akka中的AbstractActor会使用到CAS来更新它的内部状态：
// Scala代码，描述Akka中的Actor状态更新
import akka.actor.AbstractActor
class MyActor extends AbstractActor {
private var state: State = _
def receive = {
case UpdateState(newState) =>
// Atomically update state with CAS
stateUpdater.compareAndSet(this, state, newState)
// ...
}
}
6.2.2 Vert.x中的异步协同
Vert.x是另一个建立在JUC之上的高性能框架，它使用事件循环机制和回调来保证非阻塞行为。在Vert.x中，例如SharedData提供的并发数据结构就是使用了JUC中的锁和同步器来确保数据一致性。 例如，Vert.x中的AsyncMap实现，可以是这样的：
// Java代码，描述Vert.x中的异步协调和数据共享示例
import io.vertx.core.shareddata.AsyncMap;
public class VertxAsyncMapExample {
private AsyncMap<String, String> asyncMap;
public void shareData(Vertx vertx) {
vertx.sharedData().<String, String>getAsyncMap("my-map", res -> {
if (res.succeeded()) {
asyncMap = res.result();
asyncMap.put("key", "value", resPut -> {
if (resPut.succeeded()) {
// Handle successful put operation
}
});
}
});
}
}
这其中，保证数据安全性和线程同步的背后机制大量依赖于CAS和AQS。尤其是在并发环境下对异步结果或状态进行修改的时候，CAS保证了更新的原子性，而AQS提供了等待和唤醒线程的能力。
