单例问题
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操作应该是：
- 分配一块内存M
- 在内存上初始化Singleton对象
- 然后把M的地址赋值给instance变量
但是由于有序性的问题，发生指令重排，实际执行步骤是：
- 分配一块内存M
- 然后把M的地址赋值给instance变量
- 在内存上初始化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
- 管程中锁规则，对一个锁的解锁Happens-Before于加锁的过程，所以synchronized是对管程的实现，操作是可见的
- 线程start()规则，A启动子线程B，B能看到在启动B之前的所有操作
- 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共享一个缓冲行
如何避免呢？
每个变量独占一个缓冲行，不共享缓冲行就行，使用缓存行填充技术
//一个long8个字节
class Padding{
long p1,p2....,p7;
}
class Value extends Padding{
volatile long value;
}
