CAS和synchronized原理

synchronized与CAS

Synchronized 原理
- 加锁工作过程
- 一些优化
CAS
- 实现原子类
小结

Synchronized 原理

synchronized 既可以是乐观锁, 也可以是悲观锁.
synchronized 既可以是轻量级锁, 也可以是重量级锁.
synchronized 重量级锁是由系统的互斥锁实现的; 轻量级锁是基于自旋锁实现的.
synchronized 是非公平锁(不会遵守先来后到).
synchronized 是可重入锁(内部会记录哪个线程拿到了锁, 记录引用计数).
synchronized 不是读写锁.

Synchronized的内部实现策略?
可能会产生一系列的"自适应"的过程, 叫做锁升级.
无锁 -> 偏向锁 -> 轻量级锁 -> 重量级锁.

加锁工作过程

偏向锁: 偏向锁不会真的加锁, 只是做了一个标记.如果有别的线程来竞争了, 才会真的加锁.如果没有别的线程竞争, 就始终不会真的加锁.(能不加就不加)
轻量级锁: synchronized通过自旋锁的方式实现轻量级锁.
一个线程把锁占据之后, 另一个线程就会按照自旋的方式反复查询当前锁是否被释放了,
但是, 如果这把锁的线程越来越多了(锁竞争更激烈了), 就会升级为重量级锁.

一些优化

锁消除: 编译器会智能的判定当前代码是否要加锁, 如果你写了加锁, 实际上没有必要加锁, 就会把加锁操作自动删除掉.
锁粗化: 锁的粒度?
我们一般认为, 如果加锁操作中包含的实际要执行的代码越多, 就认为锁的粒度越大.
锁的粒度越小, 并发程度就更高.

for(...) {synchronized (this) {count++;}
}

锁的粒度越大, 效率就越高.

synchronized (this) {for(...) {count++;}		
}

CAS

CAS(Compare and swap).
假设内存中的原数据V, 旧的预期值A, 需要修改的新值B.
1. 比较A与V是否相等.
2. 如果比较相等, 将B写入V.
3. 返回操作是否成功.

使用CAS伪代码来辅助理解CAS的工作流程, 不是原子性代码.

// address: 内存地址. expectValue: 寄存器中的值. swapValue: 相等就替换的值
boolean CAS(address, expectValue, swapValue) {if(&address == expectValue) {&address = swapValue;return true;}return false;
}

但是这段代码逻辑, 是通过一条cpu指令完成的, 具备原子性, 就给我们编写线程安全代码, 打开了新大门.

实现原子类

标准库中提供了一组原子类, 最典型的是AtomicInteger类.
在这里插入图片描述

在这里插入图片描述

有两个构造方法.
// 设置初值为0
AtomicInteger();
// 设置初值为initialValue
AtomicInteger(int initialValue);

提供了一系列方法:

// 前置++
public final int getAndIncrement() {Atomically increments by one the current value.Returns:the previous value
}
// 前置--
public final int getAndDecrement() {Atomically decrements by one the current value.Returns:the previous value
}
// 后置++
public final int incrementAndGet() {Atomically increments by one the current value.Returns:the updated value
}
// 后置--
public final int decrementAndGet() {Atomically decrements by one the current value.Returns:the updated value
}

public class Demo28 {// 设置初值为0private static AtomicInteger count = new AtomicInteger(0);public static void main(String[] args) throws InterruptedException {Thread thread1 = new Thread(() -> {for (int i = 0; i < 5000; i++) {count.getAndIncrement();}});Thread thread2 = new Thread(() -> {for (int i = 0; i < 5000; i++) {count.getAndIncrement();}});thread1.start();thread2.start();thread1.join();thread2.join();System.out.println(count);}
}
// 结果是10000, 是原子性的.

下面使用伪代码实现原子类:

class AtomicInteger {private int value;// 前置++public int getAndIncrement() {int oldValue = value;while ( CAS(value, oldValue, oldValue+1) != true) {oldValue = value;}return oldValue;}
}
// oldValue, value, oldValue+1 都是寄存器中的值
// 如果value和oldValue相等, 就return oldValue
// 如果不等, 就把oldValue = value;

为啥会出现oldValue != value的情况呢??
因为很可能出现有别的线程穿插在两段代码之间, 把它修改了.
在这里插入图片描述
以上的图很好的描绘了如何修改代码的…

当两个线程并发的执行++操作时,如果不加任何限制,其一,就会出现串行化;
其二, 就会出现穿插, 会使结果出现问题.
通过加锁保证线程安全,强制避免穿插.
而原子类CAS保证线程安全,借助CAS来识别当前是否出现了穿插情况,如果没穿插,此时直接修改.
如果穿插了,就会重新回去内存中的值,再次尝试修改. 
多个CAS线程访问内存时,一定会有先后顺序的.
因为多个cpu在操作同一个资源, 也会涉及到锁竞争(指令级别的锁).比synchronized实现的
锁要轻量许多(cpu内部实现的机制).