关于java:基础篇JAVA原子组件和同步组件

在应用多线程并发编程的时，常常会遇到对共享变量批改操作。此时咱们能够抉择 ConcurrentHashMap，ConcurrentLinkedQueue 来进行平安地存储数据。但如果单单是波及状态的批改，线程执行程序问题，应用 Atomic 结尾的原子组件或者 ReentrantLock、CyclicBarrier 之类的同步组件，会是更好的抉择，上面将一一介绍它们的原理和用法

原子组件的实现原理 CAS
AtomicBoolean、AtomicIntegerArray 等原子组件的用法、
同步组件的实现原理
ReentrantLock、CyclicBarrier 等同步组件的用法

cas 的底层实现能够看下之前写的一篇文章: 详解锁原理，synchronized、volatile+cas 底层实现

可用来实现变量、状态在多线程下的原子性操作
可用于实现同步锁(ReentrantLock)

原子组件的原子性操作是靠应用 cas 来自旋操作 volatile 变量实现的
volatile 的类型变量保障变量被批改时，其余线程都能看到最新的值

cas 则保障 value 的批改操作是原子性的，不会被中断

AtomicBoolean // 布尔类型
AtomicInteger // 正整型数类型
AtomicLong      // 长整型类型

应用示例

public static void main(String[] args) throws Exception {AtomicBoolean atomicBoolean = new AtomicBoolean(false);
    // 异步线程批改 atomicBoolean
    CompletableFuture<Void> future = CompletableFuture.runAsync(() ->{
   try {Thread.sleep(1000); // 保障异步线程是在主线程之后批改 atomicBoolean 为 false
       atomicBoolean.set(false);
   }catch (Exception e){throw new RuntimeException(e);
   }
    });
    atomicBoolean.set(true);
    future.join();
    System.out.println("boolean value is:"+atomicBoolean.get());
}
--------------- 输入后果 ------------------
boolean value is:false

AtomicReference
// 加工夫戳版本的援用类原子类
AtomicStampedReference
// 相当于 AtomicStampedReference，AtomicMarkableReference 关怀的是
// 变量是否还是原来变量，两头被批改过也无所谓
AtomicMarkableReference

AtomicReference 的源码如下，它外部定义了一个 volatile V value，并借助 VarHandle(具体子类是 FieldInstanceReadWrite) 实现原子操作，MethodHandles 会帮忙计算 value 在类的偏移地位，最初在 VarHandle 调用 Unsafe.public final native boolean compareAndSetReference(Object o, long offset, Object expected, Object x)办法原子批改对象的属性

public class AtomicReference<V> implements java.io.Serializable {
    private static final long serialVersionUID = -1848883965231344442L;
    private static final VarHandle VALUE;
    static {
   try {MethodHandles.Lookup l = MethodHandles.lookup();
       VALUE = l.findVarHandle(AtomicReference.class, "value", Object.class);
   } catch (ReflectiveOperationException e) {throw new ExceptionInInitializerError(e);
   }
    }
    private volatile V value;
    ....

线程 X 筹备将变量的值从 A 改为 B，然而这期间线程 Y 将变量的值从 A 改为 C，而后再改为 A；最初线程 X 检测变量值是 A，并置换为 B。但实际上，A 曾经不再是原来的 A 了
解决办法，是把变量定为惟一类型。值能够加上版本号，或者工夫戳。如加上版本号，线程 Y 的批改变为 A1->B2->A3，此时线程 X 再更新则能够判断出 A1 不等于 A3

AtomicStampedReference 的实现和 AtomicReference 差不多，不过它原子批改的变量是volatile Pair<V> pair;，Pair 是其内部类。AtomicStampedReference 能够用来解决 ABA 问题

public class AtomicStampedReference<V> {
    private static class Pair<T> {
   final T reference;
   final int stamp;
   private Pair(T reference, int stamp) {
       this.reference = reference;
       this.stamp = stamp;
   }
   static <T> Pair<T> of(T reference, int stamp) {return new Pair<T>(reference, stamp);
   }
    }
    private volatile Pair<V> pair;

如果咱们不关怀变量在两头过程是否被批改过，而只是关怀以后变量是否还是原先的变量，则能够应用 AtomicMarkableReference

AtomicStampedReference 的应用示例

public class Main {public static void main(String[] args) throws Exception {Test old = new Test("hello"), newTest = new Test("world");
   AtomicStampedReference<Test> reference = new AtomicStampedReference<>(old, 1);
   reference.compareAndSet(old, newTest,1,2);
   System.out.println("对象："+reference.getReference().name+"; 版本号："+reference.getStamp());
    }
}
class Test{Test(String name){this.name = name;}
    public String name;
}
--------------- 输入后果 ------------------
对象：world; 版本号：2

AtomicIntegerArray     // 整型数组
AtomicLongArray         // 长整型数组
AtomicReferenceArray    // 援用类型数组

数组原子类外部会初始一个 final 的数组，它把整个数组当做一个对象，而后依据下标 index 计算法元素偏移量，再调用 UNSAFE.compareAndSetReference 进行原子操作。数组并没被 volatile 润饰，为了保障元素类型在不同线程的可见，获取元素应用到了 UNSAFEpublic native Object getReferenceVolatile(Object o, long offset)办法来获取实时的元素值

应用示例

// 元素默认初始化为 0
AtomicIntegerArray array = new AtomicIntegerArray(2);
// 下标为0的元素，期待值是 0，更新值是1
array.compareAndSet(0,0,1);
System.out.println(array.get(0));
--------------- 输入后果 ------------------
1

AtomicIntegerFieldUpdater 
AtomicLongFieldUpdater
AtomicReferenceFieldUpdater

如果操作对象是某一类型的属性，能够应用 AtomicIntegerFieldUpdater 原子更新，不过类的属性须要定义成 volatile 润饰的变量，保障该属性在各个线程的可见性，否则会报错

应用示例

public class Main {public static void main(String[] args) {AtomicReferenceFieldUpdater<Test,String> fieldUpdater = AtomicReferenceFieldUpdater.newUpdater(Test.class,String.class,"name");
   Test test = new Test("hello world");
   fieldUpdater.compareAndSet(test,"hello world","siting");
   System.out.println(fieldUpdater.get(test));
   System.out.println(test.name);
    }
}
class Test{Test(String name){this.name = name;}
    public volatile String name;
}
--------------- 输入后果 ------------------
siting
siting

Striped64
LongAccumulator
LongAdder
//accumulatorFunction：运算规定，identity：初始值
public LongAccumulator(LongBinaryOperator accumulatorFunction,long identity)

LongAccumulator 和 LongAdder 都继承于 Striped64，Striped64 的次要思维是和 ConcurrentHashMap 有点相似，分段计算，单个变量计算并发性能慢时，咱们能够把数学运算扩散在多个变量，而须要计算总值时，再一一累加起来
LongAdder 相当于 LongAccumulator 一个特例实现

LongAccumulator 的示例

public static void main(String[] args) throws Exception {LongAccumulator accumulator = new LongAccumulator(Long::sum, 0);
    for(int i=0;i<100000;i++){CompletableFuture.runAsync(() -> accumulator.accumulate(1));
    }
    Thread.sleep(1000); // 期待全副 CompletableFuture 线程执行实现，再获取
    System.out.println(accumulator.get());
}
--------------- 输入后果 ------------------
100000

java 的少数同步组件会在外部保护一个状态值，和原子组件一样，批改状态值时个别也是通过 cas 来实现。而状态批改的保护工作被 Doug Lea 形象出 AbstractQueuedSynchronizer(AQS)来实现
AQS 的原理能够看下之前写的一篇文章: 详解锁原理，synchronized、volatile+cas 底层实现

ReentrantLock、ReentrantReadWriteLock 都是基于 AQS(AbstractQueuedSynchronizer)实现的。因为它们有偏心锁和非偏心锁的辨别，因而没间接继承 AQS，而是应用外部类去继承，偏心锁和非偏心锁各自实现 AQS，ReentrantLock、ReentrantReadWriteLock 再借助外部类来实现同步

ReentrantLock 的应用示例

ReentrantLock lock = new ReentrantLock();
if(lock.tryLock()){
    // 业务逻辑
    lock.unlock();}

ReentrantReadWriteLock 的应用示例

public static void main(String[] args) throws Exception {ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    if(lock.readLock().tryLock()){ // 读锁
   // 业务逻辑
   lock.readLock().unlock();
    }
    if(lock.writeLock().tryLock()){ // 写锁
   // 业务逻辑
   lock.writeLock().unlock();
    }
}

Semaphore 和 ReentrantLock 一样，也有偏心和非公平竞争锁的策略，一样也是通过外部类继承 AQS 来实现同步
艰深解释：假如有一口井，最多有三个人的地位打水。每有一个人打水，则须要占用一个地位。当三个地位全副占满时，第四个人须要打水，则要期待前三个人中一个来到打水位，能力持续获取打水的地位

应用示例

public static void main(String[] args) throws Exception {Semaphore semaphore = new Semaphore(2);
    for (int i = 0; i < 3; i++)
   CompletableFuture.runAsync(() -> {
       try {System.out.println(Thread.currentThread().toString() + "start");
           if(semaphore.tryAcquire(1)){Thread.sleep(1000);
               semaphore.release(1);
               System.out.println(Thread.currentThread().toString() + "无阻塞完结");
           }else {System.out.println(Thread.currentThread().toString() + "被阻塞完结");
           }
       } catch (Exception e) {throw new RuntimeException(e);
       }
   });
    // 保障 CompletableFuture 线程被执行，主线程再完结
    Thread.sleep(2000);
}
--------------- 输入后果 ------------------
Thread[ForkJoinPool.commonPool-worker-19,5,main] start 
Thread[ForkJoinPool.commonPool-worker-5,5,main] start 
Thread[ForkJoinPool.commonPool-worker-23,5,main] start 
Thread[ForkJoinPool.commonPool-worker-23,5,main] 被阻塞完结 
Thread[ForkJoinPool.commonPool-worker-5,5,main] 无阻塞完结 
Thread[ForkJoinPool.commonPool-worker-19,5,main] 无阻塞完结

能够看出三个线程，因为信号量设定为2，第三个线程是无奈获取信息胜利的，会打印阻塞完结

CountDownLatch 实现原理和应用场景
CountDownLatch 也是靠 AQS 实现的同步操作
艰深解释：玩游戏时，如果主线工作须要靠实现五个小工作，主线工作能力持续进行时。此时能够用 CountDownLatch，主线工作阻塞期待，每实现一小工作，就 done 一次计数，直到五个小工作全副被执行能力触发主线

应用示例

public static void main(String[] args) throws Exception {CountDownLatch count = new CountDownLatch(2);
    for (int i = 0; i < 2; i++)
   CompletableFuture.runAsync(() -> {
       try {Thread.sleep(1000);
           System.out.println("CompletableFuture over");
           count.countDown();} catch (Exception e) {throw new RuntimeException(e);
       }
   });
    // 期待 CompletableFuture 线程的实现
    count.await();
    System.out.println("main over");
}
--------------- 输入后果 ------------------
 CompletableFuture over 
 CompletableFuture over 
 main over

CyclicBarrier 则是靠 ReentrantLock lock 和Condition trip属性来实现同步
艰深解释：CyclicBarrier 须要阻塞全副线程到 await 状态，而后全副线程再全副被唤醒执行。设想有一个栏杆拦住五只羊，须要当五只羊一起站在栏杆时，栏杆才会被拉起，此时所有的羊都能够飞跑出羊圈

应用示例

public static void main(String[] args) throws Exception {CyclicBarrier barrier = new CyclicBarrier(2);
    CompletableFuture.runAsync(()->{
   try {System.out.println("CompletableFuture run start-"+ Clock.systemUTC().millis());
       barrier.await(); // 须要期待 main 线程也执行到 await 状态能力继续执行
       System.out.println("CompletableFuture run over-"+ Clock.systemUTC().millis());
   }catch (Exception e){throw new RuntimeException(e);
   }
    });
    Thread.sleep(1000);
    // 和 CompletableFuture 线程互相期待
    barrier.await();
    System.out.println("main run over!");
}
--------------- 输入后果 ------------------
CompletableFuture run start-1609822588881
main run over!
CompletableFuture run over-1609822589880

StampedLock 不是借助 AQS，而是本人外部保护多个状态值，并配合 cas 实现的
StampedLock 具备三种模式：写模式、读模式、乐观读模式

StampedLock 的读写锁能够互相转换

// 获取读锁，自旋获取，返回一个戳值
public long readLock()
// 尝试加读锁，不胜利返回 0
public long tryReadLock()
// 解锁
public void unlockRead(long stamp) 
// 获取写锁，自旋获取，返回一个戳值
public long writeLock()
// 尝试加写锁，不胜利返回 0
public long tryWriteLock()
// 解锁
public void unlockWrite(long stamp)
// 尝试乐观读读取一个工夫戳，并配合 validate 办法校验工夫戳的有效性
public long tryOptimisticRead()
// 验证 stamp 是否无效
public boolean validate(long stamp)

应用示例

public static void main(String[] args) throws Exception {StampedLock stampedLock = new StampedLock();
    long stamp = stampedLock.tryOptimisticRead();
    // 判断版本号是否失效
    if (!stampedLock.validate(stamp)) {
   // 获取读锁，会空转
   stamp = stampedLock.readLock();
   long writeStamp = stampedLock.tryConvertToWriteLock(stamp);
   if (writeStamp != 0) { // 胜利转为写锁
       //fixme 业务操作
       stampedLock.unlockWrite(writeStamp);
   } else {stampedLock.unlockRead(stamp);
       // 尝试获取写读
       stamp = stampedLock.tryWriteLock();
       if (stamp != 0) {
           //fixme 业务操作
           stampedLock.unlockWrite(writeStamp);
       }
   }
    }
}

并发之 Striped64（l 累加器）

前言

关注公众号，一起交换，微信搜一搜: 潜行前行

github 地址，感激 star

原子组件的实现原理 CAS

利用场景

原子组件

根本类型原子类

援用类原子类

ABA 问题

数组原子类

属性原子类

累加器

同步组件的实现原理

同步组件

ReentrantLock、ReentrantReadWriteLock

Semaphore 实现原理和应用场景

CountDownLatch 实现原理和应用场景

CyclicBarrier 实现原理和应用场景

StampedLock

欢送指注释中谬误

参考文章

站内搜索