xxcupid的博客

1.背景在一些情况下，我们会遇到listenablefuture和CompletableFuture之间的转换。比如：场景1：将listenablefuture转为CompletableFuture你的代码依赖一个jar包，这个jar包的一个方法返回了一个listenablefuture，但是升级jdk7之后，你自己的代码逻辑想使用CompletableFuture来进行流程处理，但是你又没法改这个jar包，这个时候就需要将listenablefuture转为CompletableFuture来

todo

本篇继续介绍CompletableFuture的高阶使用方式。1.举例1）supplyAsync配合allOfCompletableFuture的supplyAsync配合allOf，将所有的future绑定到一起，然后所有都执行完之后触发对应操作，demo：allOf方法内部调用了andTree方法，看方法注释，该方法会根据传入的参数递归生成一棵树这段代码可能看起来有点绕，我们举个具体的例子，比如添加5个任务，那么cfs是个size为5的数组，lo是0，hi是4，根据这组参数，

前几篇介绍了CompletableFuture的最简单的使用方式。本篇介绍几种更高阶的使用方式。1.举例首先上个最简单的例子：1）supplyAsync配合thenCombineCompletableFuture的supplyAsync配合thenCombine方法，在通过supplyAsync拿到结果之后，结合另一个future，然后将两个结果都拿到然后做操作：因为supplyAsync在之前的文章中已经提到了，这里只说thenCombine。thenCombine方法中会调用bi

上篇https://blog.youkuaiyun.com/xxcupid/article/details/115375063，介绍了CompletableFuture的最简单的使用方式，是thenRun/thenRunAsync结合complete的方式使用。本篇仍是基础使用方法介绍，再举例几种简单使用方式。1.举例首先上个最简单的例子：1）thenRun配合completeCompletableFuture配合thenRun和complete方法，通过complete触发thenRun。demo样例

todo

todo

ThreadLocal是java中很重要的一个类，可以在线程中传递值，虽然经常出现一些ThreadLocal误用的场景。本篇章会由浅入深，从普通的ThreadLocal和InheritableThreadLocal，到netty封装的FastThreadLocal，再到阿里封装的TransmittableThreadLocal，看下ThreadLocal以及其周边增强类的演化进程，所以计划会有三篇文章：ThreadLocal详解（一）ThreadLocal和InheritableThreadLoca

上一篇中提到了jvm-sandbox-repeater实践过程的一些经验。这里面再讨论下可能遇到的问题。1、线上流量采样，采样出来的数据分布是什么样的，有没有代表性2、diff 降噪，降噪过滤掉的数据是不是不重要的，不需要关心的，降噪算法是否可靠1.酷家乐实践酷家乐利用jvm-sandbox-repeater结合自己公司内部的系统以及中间件，进行了定制化的二次开发，具体参考，ppt：https://tool.lu/index.php/en_US/deck/qj/detail?slide=8，视

jpsjps过滤出java本身的进程以及运行的引导类（即引导的Main方法所在的类）。$ sudo jps -l26513 sun.tools.jps.Jps8538 org.apache.catalina.startup.Bootstrap两个进程，jps本身的进程，还有tomcat的Bootstrap的容器引导类。jps命令也是基于java实现的。

synchronizedsynchronized是针对一个临界区的，所谓临界区就是指访问这个地方最多只能有一个线程在里面（比如一支笔可以被多人共用，但是在一段时间内只能一个人使用）。synchronized通过在对象上加锁后进入临界区来达到临界区串行化访问的目的。对象本身的作用域将决定锁的粒度。1.普通方法前加synchronized等价于在方法体前后包装一个s

对于一些集合类，比如ArrayList，LinkedList，HashMap等等，我们可能会用锁来处理对它们的并发读写操作，或者通过java本身提供的集合类来解决并发问题。以List为例，对于列表结构，如果要控制并发读写操作，以前要么自己加锁处理，要么利用Vector集合类，但是这会导致一些问题，暂且不说synchronized本身的开销，还会导致锁的粒度非常大。比如Vector中

CountDownLatch线程join可以实现等待某些线程结束，但是它仅仅能等待结束，这种方式需要逐个去等待。而CountDownLatch是等待一个信号量，当信号量达到设定数字时，等待线程就会被激活了。CyclicBarrier可以重复使用。假设一个需要5个步骤的操作，每个步骤都需要3个线程工作，对每个步骤这三个线程都要同时开始，不管上一个步骤谁先结束。这种场景

阻塞队列模型阻塞队列的接口为BlockingQueue。①LinkedBlockingQueue基于链表结构的阻塞队列，可通过重载的构造方法设定最大值。默认是Integer.MAX_VALUE，相当于无界。②ArrayBlockingQueue功能类似LinkedBlockingQueue，区别在于它是基于数组来实现的。③PriorityBloc

常见问题Vector和CopyOnWriteArrayList是线程安全的，是说它的多线程发生单次读写不会出问题，但不代表两次读写操作过程中没有任何其他的线程写入数据。Atomic实现了线程安全操作，但不代表对Atomic多次写入过程中没有其他线程写入。线程池和各种队列很好用，但是使用不当也会导致各种问题。synchronized锁粒度问题一个人进入

主从同步与备份一套主从库通常会有一个可写的主库（也有双主互备结构的），可写的主库发生数据修改之后，可能会以推的方式发送到从库，或者从库轮询从主库上拉修改的数据。① 逻辑模式基于主库执行的SQL，到从库上去执行相同的SQL，也可能基于主库上执行的SQL时所影响的数据行，进一步根据这些行的主键生成一些列SQL语句到从库上执行。这种粒度最细，最容易识别，但是生成的SQL会比较

编译器优化java编译器在对String a = “a”+“b”这种操作的时候，会直接在编译器优化为String a=“ab”；而不会等到运行时才做。同理，int i=1+2*3;这种操作也是在编译时就算好了结果是7.编译器会把能做的工作提前做好，提高效率和速度。对于String a = "a"; String c = "b"+a;这种的，编译器不会做优化，因为a的引用

就近原则计算机的缓存结构设计——就近原则，举例处理器越近，操作延迟就越小。平时设计系统的缓存也是，内存缓存最快，redis缓存有网络传输，距离更远，延迟会更大。多核的cache之间会存在缓存一致性的问题。堆和栈对C/C++来说，如果不是通过malloc，new或者realloc来分申请空间的话，那么作用域结束时空间自动释放。这部分回收操作时通过OS来

线程安全与处理器核数多核处理器会有可见性问题引发的线程安全问题。单核处理器不会有这种问题，但是也会有一致性问题，因为CPU有时间片原则，还会重排序等等。并发内存模型为了提升性能，CPU会cache许多数据。在多核CPU下，每个CPU都有自己独立的cache，每个CPU都可以修改同一个单元数据，有自己的一套缓存一致性协议——从CPU的角度认为某些来自主存的数据

HeapSize OOMpublic static void main(String[] args) {List list = Lists.newArrayList();while (true) {list.add("hello");}}会抛如下异常Exception in thread "main" java.lang.OutOfMemoryErr

原始类型与对象的拆装箱boolean，byte，char，short，int，long，float，double都有一个装箱后的类型（Wrapper）与之对应。JDK1.5之后它们可以互相转换，自动装箱对int来说使用Integer.valueOf()来完成。这一操作在编译期完成。int []values = new int[1024];for(...){val

java设计的初衷就是为了网络，网络的基础就源自于通信。java进程并不真正参与网络通信，而只是将数据交由Kernel去处理。两组接口InputStream和OutputStream这两个接口是操作字节的。Reader和Writer操作的是字符，其实是通过对前者的封装得到的。BufferInputStream和BufferOutputStream

常规IO操作过程java程序普通的IO过程，都会经历从Kernel到JVM的内存拷贝。例如做一次文件拷贝，一般会开启一个输入流，将文件读取到JVM内存中，然后开启一个输出流，将内存中数据输出到另一个文件中（一个文件->kernel->JVM内存->另一个文件）。不是磁盘->磁盘，不是磁盘->内存，而是会经历一个内核区。拷贝内存速度很快，但是反复大量拷贝也

什么时候用异步如果一个动作需要相对较长的时间等待，即大部分时间消耗在这里，那么可以利用这段时间做点别的事情。如果这个动作时间很短，没有必要用这段时间做别的事情了。因为我们做另一件事和回来再做刚才正在做的事情的时候，在行为和思维上都需要存档（比如写代码被人打断商量事情，回来之后忘了写到哪里了，得想一会儿）。计算机也是这样，线程切换需要保存上下文，这些开销也很大，所以不要盲

tomcat配置tomcat的配置体系，如Server，Service，Executor，HTTP等。这是tomcat从外层到内层的访问机制。tomcat启动时，是启动java的main方法。tomcat的lib目录下有一个catalina的jar包，引导方法main就在这个jar包的BootStrap类中，用jps等命令可以在JVM进程中看到。跟踪源码会发现，系统启动

Thread所有java程序都是在进程中分配线程来处理的。如果是一个main方法，则由一个主线程来处理。如果不创建自定义线程，那么这个程序就是单线程的。单独创建线程要使用Thread类，可以扩张Thread的run方法，也可以创建一个Thread，将一个Runnable任务实体传入。一个Runnable实体是一个任务，而不是一个线程。一个线程的启动需要通

内存跑程序的地方。是磁盘存储和CPU之间的一座缓冲区桥梁。现代的PC，内存的大小在一定场景下可以决定计算机的整体能力。在32位系统中，1.5G的heap区域是比较合适的，因为JVM除了需要这部分空间，还需要很多其他空间，需要为这些开销预留。随机读写与顺序读写磁盘每次发生读写操作都要先寻找位置，如果频繁发生磁盘小IO请求，就会频繁寻找位置，即随机读写。

IO只要是与内存程序通信的，就可以将其理解为IO。内存中处理好的数据反馈到某个设备上，这才算IO。CPU是真正处理的实体，不算IO设备。CPU是老大，内存是保护CPU的，任何东西要接触CPU都要先过内存这一关。常见的几种IO：向磁盘中读取写入数据，和远远的程序通信，向控制台输出数据。网络IO最重要的就是网络IO，网络IO才使得系统间的

Heap区Heap，堆，氛围Young和Old两个板块。两个板块在分配内存上和Heap很相似，但是回收差别很大。通常Young空间会小很多。参考值Young大概是Old的1/4~1/3，Young区Young区被分为两个部分，三个板块。1个Eden区+2个Survivor区。Eden区：使用new或者newInstance创建的对象默认都分配在Ede

串行GC与并行GC一个线程做GC，不要考虑征用和锁的问题以及开销。适用场景：单机程序，客户端代码，小内存程序（小于100M），CPU数量有限。并发量大，或者处理大数据的服务端程序，通常用较大内存承载用户的访问。面对较大内存，对YoungGC用串行GC还可以，FullGC用串行GC回收效率远远不够。对于这种情况，线程分配的开销通常是值得的。而且服务器一般有很多很好

用javap看一下自增操作的实现int a=1,b=1,c=1;c++;int d=a++;b=b++;这时c=1这个好理解，那么b=1，这个不好理解了。看看javap的编译过程：单独执行c++其实和单独执行++c的操作是一样的。从头解释，第一行赋值，以a=1解释：1)首先将int型的1推送到栈顶（iconst_1）2)将

AbstractQueuedSynchronizer的介绍和原理分析 * 《Java并发编程的艺术》-Java并发包中的读写锁及其实现分析 * ReentrantLock(重入锁)以及公平性 *  *  * 同步器 * {@link java.util.concurrent.locks.AbstractQueuedSynchronizer#getState()}， *

static final class NonfairSync extends Sync { private static final long serialVersionUID = 7316153563782823691L; /** * Performs lock. Try immediate barge, backing up to norm

/** * Acquires in shared uninterruptible mode. * @param arg the acquire argument */ private void doAcquireShared(int arg) { final Node node = addWaiter(Node.SHARED);

1.头结点头结点是获取锁的关键，对于Exclusive模式来说/** * Acquires in exclusive uninterruptible mode for thread already in * queue. Used by condition wait methods as well as acquire. * * @param nod

更详细权威的内容参见ReentrantLock(重入锁)以及公平性1.简介这里提到一个锁获取的公平性问题，如果在绝对时间上，先对锁进行获取的请求一定被先满足，那么这个锁是公平的，反之，是不公平的，也就是说等待时间最长的线程最有机会获取锁，也可以说锁的获取是有序的。ReentrantLock这个锁提供了一个构造函数，能够控制这个锁是否是公平的。而锁的名字也是说明了这个锁具备了重复

1.Disruptor为什么快http://ifeve.com/locks-are-bad/2.关于synchronized关键字因为Java虚拟机的优化，现在synchronized已经没有之前想象的那么慢了。具体参见：http://ifeve.com/java-synchronized/在Disruptor为什么快的问题上，博客里指出了一个实验，即“Disruptor论文中...

1.Disruptor的构造和初始化可以调用Disruptor的构造函数初始化，可以设定线程池，等待策略，ringBuffer的大小等信息。注意，在高版本的Disruptor中，带线程池的构造方法已经被打上了Deprecated标记，原文是这样解释的：使用ThreadFactory来代替Executor的原因是为了能够在无法继续创建线程来执行producer任务的时候能够报告err...

todo

前面看过了很多利用AbstractQueuedSynchronizer做的二次开发，主要是针对锁的获取和释放以及状态的读取和变更做的一系列变化。FutureTask和guava中的AbstractFuture很像，后者用一系列的set方法来设置值或异常来触发锁的释放。而FutureTask通过构造一个task任务，并用该任务的完成，用任务的返回值来设置future的value并触发锁的释放。