Java并发编程

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保存的是失败线程的线程引用，等待状态以及前驱、后继节点。

这里放一张独占式同步状态获取流程图

image.png

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是大小无界的线程池，适用于执行很多的短期异步任务的小程序，或者是负载比较轻的服务器

Java并发编程