单例问题

class Singleton {
    private static Singleton instance;
    static Singleton getInstance(){
        if(instance == null){
            synchronized (Singleton.class){
                if(instance == null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

上面是一个双重校验获取单例的方法，有什么问题呢？除了构造方法没有私有化的缺陷，还有一个重要的问题，两个线程在同时调用getInstance方法的时候，在后续的逻辑里可能会空指针

问题出现在new操作上，我们以为的new操作应该是：

1. 分配一块内存M
2. 在内存上初始化Singleton对象
3. 然后把M的地址赋值给instance变量

但是由于有序性的问题，发生指令重排，实际执行步骤是：

1. 分配一块内存M
2. 然后把M的地址赋值给instance变量
3. 在内存上初始化Singleton对象
   此时，某个现在在第一个if判断的时候就会失败，直接把instance返回，导致后面的操作报空指针

问题的原因是并发编程有序性的问题，就是编译器优化导致的，解决可见性问题最直接的方法就是禁用缓存和编译优化（会有部分性能的损失），可以用volatile语义进行声明，可以禁止指令重排序

volatile的使用

class VolatileDemo {
    int x = 0;
    volatile boolean v = false;

    public void writer() {
        x = 100;
        v = true;
    }

    public void reader() {
        if (v == true) {
            System.out.println();
            //这里的x是多少（由于sout有synchronized不要用）
        }
    }
}

两线程并发执行，一个writer，一个reader，上x是多少？0和100都对，这个要看java版本，如果低于1.5上运行，x可能是0，也可能是100，如果在1.5以上的运行，x就是100

被Volataile的作用修饰表达的是，告诉编译器，对这个变量的读写不能使用CPU缓存，必须从内存中读取或者写入

Java内存模型在1.5对volatile语义进行了增强，增加了一项Happens-Before的原则（volatitle变量规则），Happens-Before原则表示前面的一个操作结果对后续操作是可见的（多线程之间也是可见的）

1.程序的顺序性规则，指程序按照顺序去执行，比如x=100HappenBefore于v=true
2.volatitle变量规则，这条规则指对一个volatile变量的写操作Happens-Before于后续对这个vlatile变量的读操作（还是禁用缓存的意思）
3.传递性，如果A Happens-Before B,且B Happens-Before C，那么，A Happens-Before C，这里就可以解释为什么是100了，

• x=100Happens-Before 写变量v=true，这是规则一的内容
• 写变量v=true，Happens-Before 读变量v=true，这是规则2
• x=100Happens-Before 读变量v=true,这是规则3

所以，如果线程B读到v=true，那没A设置的x=100，就是对线程B可见的，所以就是100

4. 管程中锁规则，对一个锁的解锁Happens-Before于加锁的过程，所以synchronized是对管程的实现，操作是可见的
5. 线程start()规则，A启动子线程B，B能看到在启动B之前的所有操作
6. join规则，自线程B返回后，A可以看到B中的所有操作

管程

管程，对应的英文是monitor，很多Java领域喜欢翻译成监视器，但是操作系统一般都翻译成管程，所谓管程，指的是管理共享变量的操作过程，让他们支持并发，synchronized的实现

管程先后出现过三种不同的模型，分别是，Hasen模型，Hoare模型和MESA模型，其中广泛应用是MESA模型，并且Java管程也是参考的MESA模型

CompletableFuture

创建CompletableFuture对象

• CompletableFuture.supplyAsync
  有返回值的创建
• CompletableFuture.runAsync
  没有返回值的创建
• new CompletableFuture()
  通过new创建，使用api来complete和exception

supply和run同时支持在创建中传入线程池，默认使用公共的ForkJoinPool线程池（建议分开线程池，否则慢线程会影响所有的执行）

CompletionStage的作用

CompletableFuture除了实现Future的接口外（获取异步操作的结果），还实现了CompletionStage，用来组合描述Future之间的关系，以及异步的异常处理

• AND关系，汇聚关系，(A,B)->C，A，B两个异步任务执行完成后执行任务C
  1.使用thenCombine来实现
  2.使用thenAcceptBoth和runAfterBoth
  主要是，对于C执行的时候参数和和返回值的不同（run没有参数，没有返回值，Accept有参数无返回值，Combine有参数有返回值）

public static void main(String[] args) {
        System.out.println("main thread name:" + Thread.currentThread().getName());
        CompletableFuture<Void> A = CompletableFuture.runAsync(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("thread A exec success:" + Thread.currentThread().getName());
        });
        CompletableFuture<String> B = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("thread B exec success:" + Thread.currentThread().getName());
            return "thread B success";
        });
        CompletableFuture<String> C = A.thenCombine(B, (__, bReturn) -> {
            System.out.println("b Return value :" + bReturn);
            System.out.println("thread C exec success:" + Thread.currentThread().getName());
            return "success";
        });

        try {
            System.out.println(C.get());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
输出结果：(C是在唤醒的线程里支持)
thread B exec success:ForkJoinPool.commonPool-worker-2
thread A exec success:ForkJoinPool.commonPool-worker-1
b Return value :thread B success
thread C exec success:ForkJoinPool.commonPool-worker-1
success

• 串行关系，A->B->C
  使用，thenApply、thenAccept、thenRun、thenCompose这些接口（这些方法后面加Async都是一部去执行fn）
  1.thenApply，既能接受参数，也支持返回值
  2.thenAccept，接收参数但是无返回值
  3.thenRun，没有参数也没有返回值
  4.thenCompose，会创建出来一个子流程，最终结果和thenApply是相同的

• OR关系，(A || B)->C，A或B执行成功后执行C
  使用applyToEither，acceptEither和runAfterEither，和And关系一样都是参数和返回值的不同

• 异常处理
  1.使用exceptionally，相当于try{}catch{}中的catch块
  2.使用whenComplete，相当于try{}finally{}中的finally块，不支持返回结果
  3.使用handle,相当于try{}finally{}中的finally块和whenComplete相比是支持返回值的，所以在handle中的返回值是真正的异步返回值(注意handle和exceptionally的位置，如果handle在前，exceptionally是不会被调用的)

优雅的终止线程

• 设置线程终止标志位，在run方法中while(isTerminated)来判断，通过volatile来修饰
• ”毒丸“，比如线程中在消费消息，如果消费到 制定的对象（或者数据）则终止操作

局部性原理

程序的局部性原理指的是，在一段时间内，程序的执行会限定在一个局部范围，这个局部范围包括，时间局部性，和空间局部性

• 时间局部性，指的是程序中的某条指令一旦被执行不久之后可能会再次被执行
• 空间局部性，指某块空间一旦被访问过，不久之后这块内存附近的内存也可能被访问

CPU缓存就是利用程序局部性原理，CPU在加载数据X时，会将数据X缓存到高速Cache中，同时还会缓存X周围的数据

所以，数组会比链表的读速度快，因为数组是连续的，但是要注意，如果数据里面存的是对象，那么数组的效率还可以进一步的提高，因为，数据中存的地址是连续的，但是元素实际的位置并不是连续的，所以还需要每次寻址，Disruptor内部的Ringbuffer在保持对象的时候空间也是连续的，所以会特别的快

伪共享问题

伪共享，指的是由于共享缓存行为导致缓存无效的场景

伪共享的现象如，ArrayBlockingQueue中有

final object[] items;//元素
int takeIndex;//入队索引
int putIndex;//出队索引
int count;//元素个数

CPU由于CPU缓存在加载takeIndex的时候，会将putIndex和count都加载到缓冲中（缓存行的大小一般都是64字节），线程1执行入队操作使用CPU1，和线程2执行出队操作使用CPU2，由于入队操作的操作，导致缓存失效，所以CPU-2必须从内存中重新读取takeIndex（由于putIndex和takeIndex共享一个缓冲行），ArrayBlockQueu入队和出队是通过锁来保证互斥的，所以putIndex和takeIndex共享一个缓冲行

image.png

如何避免呢？

每个变量独占一个缓冲行，不共享缓冲行就行，使用缓存行填充技术

//一个long8个字节
class Padding{
  long p1,p2....,p7;
}
class Value extends Padding{
  volatile long value;
}