CAS
Compare and Swap ,CAS操作需要输入两个数值,一个旧值和新值,在操作期间先比较旧值有没有发生变化,如果没有才交换成新值,发生了变化则不交换。
如何实现一个安全的i++
private AtomicInteger atomicI = new AtomicInteger(0);
private void safeCount(){
for(;;){
int i = atomicI.get();
boolean suc = atomicI.compareAndSet(i,++i);//CAS操作
if(suc) break;
}
}
}
CAS实现原子操作的三大问题
ABA问题
1)解决办法是加上一个版本号,每次变量更新的时候版本号加1,那么A->B->A就会变成1A->2B->3A。
2)jdk的Atomic包里就提供了一个类AtomicStampedReference来解决ABA问题,这个类中的compareAndSet方法的作用就是首先检查当前引用是否等于预期引用,并且检查当前标志是否等于预期标志,如果全部相等,则以原子方式将该引用和该标志的值更新为指定的新值。循环时间长开销大
自旋CAS如果长时间不成功,会给CPU带来大的开销,如果jvm能支持处理器提供的pause指令,那么效率会有一定的提升。pause指令有两个作用:
1)它可以延迟流水线执行指令(de-pipeline),使CPU不会消耗过多的执行资源,延迟的时间取决于具体实现的版本,在一些处理器上延迟时间是零。
2)它可以避免在退出循环的时候因内存顺序冲突(Memory Order Violation)而引起CPU流水线被清空(CPU Pipeline Flush),从而提高CPU的执行效率。只能保证一个共享变量的原子操作
多个共享变量操作时,循环CAS就无法保证操作的原子性,这个时候就可以用锁。
1)解决办法就是把多个共享变量合并成一个共享变量来操作。比如,有两个共享变量i=2,j=a合并一下ij=2a,然后用CAS来操作ij。
2)JDK提供了AtomicReference类来保证引用对象之间的原子性,就可以把多个变量放在一个对象里来进行CAS操作。
JMM内存模型
这篇文章基本和《Java并发编程的艺术》一致:https://www.jianshu.com/p/8a58d8335270
JMM内存模型三大特性
- 原子性
如AtomicInteger对Integer的增减操作
使用 synchronized 互斥锁来保证操作的原子性 - 可见性
volatile会强制将该变量自己和当时其他变量的状态都刷出缓存。
synchronized,对一个变量执行 unlock 操作之前,必须把变量值同步回主内存。
final,被 final 关键字修饰的字段在构造器中一旦初始化完成,并且没有发生 this 逃逸(其它线程通过 this 引用访问到初始化了一半的对象),那么其它线程就能看见 final 字段的值。 - 有序性
源代码 -> 编译器优化的重排 -> 指令并行的重排 -> 内存系统的重排 ->最终执行的命令
重排序过程不会影响到单线程程序的执行,却会影响到多线程并发执行的正确性
Java中的锁
lock接口
只有简单的几个方法lock unlock trylock(可以超时的获取锁,可以尝试非阻塞的获取锁),unlock一定要写在finally里面
AbstractQueuedSynchronizer
AQS提供了一种实现阻塞锁和一系列依赖FIFO等待队列的同步器的框架,如下图所示。AQS为一系列同步器依赖于一个单独的原子变量(state)的同步器提供了一个非常有用的基础。子类们必须定义改变state变量的protected方法,这些方法定义了state是如何被获取或释放的。鉴于此,本类中的其他方法执行所有的排队和阻塞机制。子类也可以维护其他的state变量,但是为了保证同步,必须原子地操作这些变量。
state为0表示无锁,>0代表有锁
其中compareAndSetState的实现依赖于Unsafe的compareAndSwapInt()方法
Unsafe类有几十种方法,大部分都是native方法,实现线程安全的操作,且获取unsafe类一定是BootstrapClassloader加载的,通过反射拿到的。
同步器模板主要提供的模板分为三类,独占式获取与释放锁,共享式(同一时刻可以有多个线程获取同步状态)和查询同步队列中等待线程情况
同步队列是一个双向FIFO队列,当线程获取同步状态失败时,同步器将当前线程以及等待状态构造成一个节点(Node)并加入同步队列,同时阻塞该线程,每次同步状态释放时,会把首节点的线程唤醒,让他尝试获取同步状态
Node保存的是失败线程的线程引用,等待状态以及前驱、后继节点。
这里放一张 独占式同步状态获取流程图
ReentrantLock
实现可重入,任意线程在获取到锁之后能够再次获取该锁而不会被锁所阻塞
可实现公平锁和非公平锁(nonfairTryAcquire)
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
公平锁在实现上获取同步状态的时候多了个方法hasQueuePredecessors()
判断同步队列中当前节点是否有前驱节点,有的话需要等待前驱线程获取并释放锁
ReadWriteLock读写锁接口
readLock()和writeLock()
具体实现是ReentrantReadWriteLock
这里放一个读写锁应用:用线程安全的HashMap实现cache
public class Cache {
static Map<String,Object> map = new HashMap<>();
static ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
static Lock read = rwl.readLock();
static Lock write = rwl.writeLock();
public static final Object get(String key){
read.lock();
try {
return map.get(key);
} finally {
read.unlock();
}
}
public static final Object put(String key, Object value){
write.lock();
try{
return map.put(key,value);
} finally {
write.unlock();
}
}
public static final void clear(){
write.lock();
try{
map.clear();
} finally {
write.unlock();
}
}
}
读写锁把变量状态切分成两个部分,高16位表示读,低16位表示写,写锁写状态 S & 0x0000FFFF,同样支持可重入。而读锁是可重入的共享锁,能够被多个线程获取,没有写锁的时候,读锁总是能够被获取,只是增加读状态
线程池种类和应用
- FixedThreadPool适用于为了满足资源管理的需求,而需要限制当前线程数量的应用场景,适用于负载比较重的服务器
- SingleThreadExecutor适用于需要保证顺序地执行各个任务;并且在任意时间点,不会有多个线程是活动的应用场景
- CachedThreadPool是大小无界的线程池,适用于执行很多的短期异步任务的小程序,或者是负载比较轻的服务器