一，CountDownLatch

​ 作用：CountDownLatch类能够使一个线程等待其他线程完成各自的工作后再执行。

​ 使用场景：Zookeeper分布式锁，Jmeter模拟高并发等。

​ 工作原理：CountDownLatch是通过一个计数器来实现的，计数器的初始值为线程的数量。每当一个线程完成了自己的任务后，通过调用``countDown();`方法使计数器的值就会减1，当计数器值到达0时，它表示所有的线程已经完成了任务，然后在闭锁上等待的线程就可以恢复执行任务。

public class CountDownLatchTest {
	private static CountDownLatch countDownLatsh = new CountDownLatch(5);
    private static class Player implements Runnable{
        private Integer index;
        public Player(Integer index){
            this.index = index;
        }
        @Override
        public void run() {
            System.out.println("玩家"+index+"准备完成");
            countDownLatsh.countDown();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        for(int i = 0; i < 5; i++){
            new Thread(new Player(i)).start();
        }
        countDownLatsh.await();
        System.out.println("玩家准备完毕，开始游戏");
    }
}

一，volatile的原理

volatile是Java虚拟机提供的轻量级的同步机制。volatile关键字有如下两个作用

• 保证被volatile修饰的共享变量对所有线程总数可见的，也就是当一个线程修改 了一个被volatile修饰共享变量的值，新值总是可以被其他线程立即得知。
• 禁止指令重排序优化

1.1 可见性

​ 关于volatile的可见性作用，我们必须意识到被volatile修饰的变量对所有线程总数立即 可见的，对volatile变量的所有写操作总是能立刻反应到其他线程中。

一，ConcurrentHashMap分段锁

​ HashTable容器在竞争激烈的并发环境下表现出效率低下的原因，是因为所有访问HashTable的线程都必须竞争同一把锁，那假如容器里有多把锁，每一把锁用于锁容器其中一部分数据，那么当多线程访问容器里不同数据段的数据时，线程间就不会存在锁竞争，从而可以有效的提高并发访问效率，这就是ConcurrentHashMap所使用的锁分段技术，首先将数据分成一段一段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问。有些方法需要跨段，比如size()和containsValue()，它们可能需要锁定整个表而而不仅仅是某个段，这需要按顺序锁定所有段，操作完毕后，又按顺序释放所有段的锁。这里“按顺序”是很重要的，否则极有可能出现死锁，在ConcurrentHashMap内部，段数组是final的，并且其成员变量实际上也是final的，但是，仅仅是将数组声明为final的并不保证数组成员也是final的，这需要实现上的保证。这可以确保不会出现死锁，因为获得锁的顺序是固定的。JDK1.8的实现已经抛弃了Segment分段锁机制，利用CAS+Synchronized来保证并发更新的安全。

一，synchronized底层原理

1.1 应用方式

Java中每一个对象都可以作为锁，这是synchronized实现同步的基础：

• 当synchronized作用在实例方法时，监视器锁（monitor）便是对象实例（this）；
• 当synchronized作用在静态方法时，监视器锁（monitor）便是对象的Class实例，因为Class数据存在于永久代，因此静态方法锁相当于该类的一个全局锁；
• 当synchronized作用在某一个对象实例时，监视器锁（monitor）便是括号括起来的对象实例；

一，CAS

1.1 介绍

while(true){
    // 1，预期值X
    // 2，要修改的新值Y
    if(CompareAndSet(X,Y)){
        break;
    }
}

一，Semaphore原理

​ 信号量，用来限制能同时访问共享资源的线程上限，就好像ReentrantLock只允许一个线程进去，而Semaphore最多只允许n个线程进去，常用于资源访问，服务限流(Hystrix里限流就有基于信号量方式)

1.1 简单使用

public class SemaphoreRunner {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(2);
        for (int i=0;i<5;i++){
            new Task(semaphore,"zyh"+i).start();
        }
    }
    static class Task extends Thread{
        Semaphore semaphore;
        public Task(Semaphore semaphore,String tname){
            this.semaphore = semaphore;
            this.setName(tname);
        }
        public void run() {
            try {
                semaphore.acquire();
                System.out.println(Thread.currentThread().getName()+":aquire():"+System.currentTimeMillis());
                Thread.sleep(1000);
                semaphore.release();
                System.out.println(Thread.currentThread().getName()+":release():"+System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}

一，ReentrantReadWriteLock原理

​ 读写锁用的是同一个 Sycn 同步器，因此等待队列、state 等也是同一个，写锁状态占了 state 的低 16 位，而读锁使用的是 state 的高 16 位；（state是int类型，占4个字节，4*8 = 32位）。

1.1 WriteLock的lock()

WriteLock的lock()方法：

public void lock() {
    sync.acquire(1);
}

一，ReentrantLock原理解析

​ ReentrantLock的基本实现可以概括为：先通过CAS尝试获取锁。如果此时已经有线程占据了锁，那就加入AQS队列并且被挂起。当锁被释放之后，排在CLH队列队首的线程会被唤醒，然后CAS再次尝试获取锁。在这个时候，如果：

• 非公平锁：如果同时还有另一个线程进来尝试获取，那么有可能会让这个线程抢先获取；
• 公平锁：如果同时还有另一个线程进来尝试获取，当它发现自己不是在队首的话，就会排到队尾，由队首的线程获取到锁；

1.1 AQS介绍

​ AbstractQueuedSynchronizer简称AQS，是一个用于构建锁和同步容器的框架。事实上于java.concurrent.util包内许多类都是基于AQS构建，例如ReentrantLock，Semaphore，CountDownLatch，ReentrantReadWriteLock，FutureTask等。AQS解决了在实现同步容器时设计的大量细节问题。

一，ThreadPoolExecutor

全参构造函数参数介绍，在Java中创建线程池常用的类是ThreadPoolExecutor，该类的全参构造函数如下：

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {
}

一，JMM模型

1.1 介绍

​ Java内存模型(Java Memory Model简称JMM)是一种抽象的概念，并不真实存在，它描述的是一组规则或规范，通过这组规范定义了程序中各个变量（包括实例字段，静态字段和构成数组对象的元素）的访问方式。每个JVM 的实现都要遵守JMM规范，JMM规范的保障了并发程序运行在不同的虚拟机上时，得到的程序结果是安全可靠的。如果没有JMM内存模型来规范，就可能会出现，经过不同 JVM 翻译之后，运行的结果不相同也不正确的情况。

1.2 主内存和工作内存

​ java运行时内存模型JVM运行程序的实体是线程，在每个线程创建时，JVM都会为其创建一个工作内存(有些地方称为栈空间)，用于存储线程私有的数据。Java 内存模型JMM规定所有变量都存储在主内存，主内存是共享内存区域，所有线程都可以访问，但线程对变量的操作(读取赋值等)必须在工作内存中进行。工作内存是线程私有，所以不同的线程间无法访问对方的工作内存，线程间的通信(传值)必须通过主内存来完成。