墩墩分墩

CyclicBarrier 基于 Condition 来实现的- 在CyclicBarrier类的内部有一个计数器，每个线程在到达屏障点的时候都会调用await方法将自己阻塞，此时计数器会减1，当计数器减为0的时候所有因调用await方法而被阻塞的线程将被唤醒。这就是实现一组线程相互等待的原理，下面我们先看看CyclicBarrier有哪些成员变量。

**ConcurrentLinkedDeque**： 基于`双向链表`实现的`无界非阻塞线程安全队列`，可以从队列的头和尾同时操作(插入/删除)，底层基于`自旋+CAS`的方式实现，**适合“`多生产，多消费`”的场景。**- 双端队列与普通队列的入队区别是：双端队列中元素可以在`“队首、队尾进行入队、出队”` - “**队首入队**”底层调用了`linkFirst()`方法，而“**队尾入队**”是调用了` linkLast()`方法 - “**队首出队**”底层调用了`unlinkFirst(

**ConcurrentLinkedQueue**:是一个适用于**高并发场景**，基于`单向链表`实现的`无界非阻塞线程安全队列`，使用`CAS自旋+volatile`来包保证线程安全。按照`FIFO`的方式对存储元素进行排序，该队列`不允许写入null元素`。- 由于是完全基于`无锁算法`实现的，多线程同时进行修改队列的操作（比如同时入队），很可能出现`CAS修改失败`的情况，那么失败的线程`会进入下一次自旋，再尝试入队操作，直到成功`。**所以，在并发量适中的情况下，ConcurrentLinked

- **LinkedTransferQueue**： 一个由`链表`结构组成的`无界阻塞队列`，相对于其它队列该类实现了**TransferQueue接口**，多了`transfer()和tryTransfer()`方法。 - **若当前存在一个正在等待transfer元素的消费者线程，就直接将元素 “交给” 等待者；否则会put当前元素到队尾，并进入阻塞状态，等待消费者线程transfer该元素。**

- **SynchronousQueue**： 一个 **不存储元素(没有容量)** 的阻塞队列，，`每个插入操作(put)必须等到另一个线程调用移除操作(take)` (`即: 写入元素必须被移除后才能继续写入新的元素`)，否则写入操作一直处于阻塞状态。支持公平锁（TransferQueue-FIFO）和非公平锁(TransferStack-LIFO)。相较于其他可缓存元素队列，适用于`单线程同步传递性场景`，**比如：消费者没拿走当前的产品，生产者是不能再给产品的，这样可以`控制生产者生产的速率和消费者

- **DelayQueue**： 一个`内部使用优先级队列PriorityQueue（二叉小顶堆）`实现**延迟读取** 的`无界阻塞队列`，该队列中每个元素均有*过期时间*，当从队列获取元素时，`只有过期元素才会出队列`。`队列头元素是最块要过期的元素`。**内部使用ReentrantLock和Condition实现。** - 使用**PriorityQueue**来实现队列，所以以`二叉小顶堆`结构维**护元素顺序**，**这样`剩余时间最小的元素就在堆顶`，每次出队其实就是删除剩余时间≤0的最小元

- **PriorityBlockingQueue**： 使用`基于数组的二叉堆`实现的，支持**按优先级排序**的`无界阻塞队列（其实就是线程安全的PriorityQueue）`，`写入的对象必须实现Comparable接口，或在队列构造方法传入比较器Comparator`。**默认按照自然顺序升序排序**，*缺点是不能保证同优先级元素的顺序*。**内部使用ReentrantLock和Condition实现** - 底层是一种基于`数组`实现的**堆结构**，是真正的无界队列`（仅受内存大小限制） `

- **LinkedBlockingDeque**： 由`双向链表`组成的`有界阻塞队列`，队列容量大小可选，默认大小为`Integer.MAX_VALUE`。**队头部和队尾都可以写入和移除元素**，因为`多了一个操作队列的入口`，在多线程同时入队时，也就减少了一半锁的竞争 。 - **Deque特性**: `队头`和`队尾`都可以**插入和移除元素**，支持`FIFO`和`FILO`。 - 相比于其他阻塞队列，LinkedBlockingDeque多了`addFirst()、addLast()、p

- **LinkedBlockingQueue**：由`单向链表`结构组成的`有界阻塞队列`，队列容量大小可选，默认大小为`Integer.MAX_VALUE`。按照`FIFO`的方式对存储元素进行排序。，吞吐量通常要高于ArrayBlockingQuene - **put操作和take操作分别使用不同的**`ReentrantLock`，**同一时刻，只能只有一个线程能执行入队/出队操作，其余入队/出队线程会被阻塞**，但入队和出队之间可以并发执行，**即同一时刻，可以同时有一个线程进行入队，另一个线

**ArrayBlockingQueue**：由`数组`实现的`有界阻塞队列`，在初始化时必须指定容器大小，按照`FIFO`的方式存储元素。内部使用ReentrantLock和Condition实现，支持公平锁和非公平锁。- 队列的容量一旦在构造时指定就无法更改- 插入元素时，在队尾进行；删除元素时，在队首进行；- 队列满时，写入元素会阻塞线程；队列空时，移除元素也会阻塞线程；- 支持公平/非公平策略，默认为非公平策略。

- 一个是以`ConcurrentLinkedQueue`为代表的高性能`非阻塞队列`，- 一个是以`BlockingQueue接口`为代表的`阻塞队列`，**无论哪种顶级接口都继承自Queue**。 - **BlockingQueue是一个接口**，它的实现类有`ArrayBlockingQueue、LinkedBlockingDeque、PriorityBlockingQueue、DelayQueue、SynchronousQueue 、LinkedTransferQueue、LinkedBlock

称之为信号量，与互斥锁ReentrantLock用法类似，区别就是Semaphore共享的资源是多个，允许多个线程同时竞争成功。场景：限流场景使用，限定最多允许N个线程可以访问某些资源。就像车辆行驶到路口，必须要看红绿灯指示，要等到绿灯才能通行。与CountDownLatch区别: Semaphore的“计数“被获取到后是可以释放的，并不像CountDownLatch那样一直减到底。它更多地用来限流，类似阀门的 功能。如果限定某些资源最多有N个线程可以访问，那么超过N个则不允许再有线程来访问，同时当

俗称：(同步计数器/闭锁)，是AQS共享锁的具体实现，可以使一个线程等待其他线程全部执行完毕后再执行。 类似join()的效果。场景：主要用来解决一个线程等待 N 个线程的场景。通常用来汇总各个线程执行后的结果CountDownLatch内部通过一个计数器来控制等待线程数，该计数器的操作是原子操作，即同时只能有一个线程去更新该计数器。调用await()方法的线程会一直处于阻塞状态，直到其他线程调用countDown()使当前计数器的值变为 0，每次调用countDown()方法计数器的值减1。当计数

**读写锁特点**- 允许多个线程获取同一个锁；- 读线程运行时，允许`多个读线程同时`获取锁，`但不允许写线程获取锁`；- 写线程运行时，不允许`任何线程`获取锁；- `（可选）`某一个写线程后产生的读线程，应该`等待写线程释放锁`才去获取锁；

**AQS同步器的主要实现方式是`继承`，子类通过`继承AQS同步器`并 `实现它的抽象方法` 来管理`同步状态state`**- 对于使用者来讲，我们无需关心**获取资源失败，线程排队，线程阻塞/唤醒等一系列复杂的实现**，这些都在AQS中为我们处理好了。我们只需要负责好自己的那个环节就好，也就是**获取/释放共享资源state的姿势**T_T。- 很经典的`模板方法设计模式`的应用，AQS为我们定义好`顶级逻辑的骨架`，并提取出`公用的线程入队列/出队列，阻塞/唤醒等一系列复杂逻辑的实现`，将

- ​ AQS除了`同步队列`之外，还存在`Condition队列（等待队列，也可称为条件队列）`，也是一个`FIFO的`单向队列 。该队列是Condition对象实现`线程等待/通知功能`的核心。**但条件队列不是必须的，只有当使用Condition时，才会存在此队列。并且可能会有`多个`条件队列。** - ConditionObject是AQS的**成员内部类** ，可以调用AQS同步器的`所有成员变量和方法`。内部变量`firstWaiter、lastWaiter`分别表示等待条件的`第一个节

**AbstractQueuedSynchronizer`抽象队列同步器，简称AQS`,位于` java.util.concurrent.locks 包`下，是用来构建锁或者其他同步组件的`单机多线程基础框架`**- AQS使用`模版模式`，他内置了` 获取锁、释放锁`的方法，**子类继承AQS后无需关心锁获取失败或成功之后的操作，子类应该定义一个`非公开的内部类继承AQS`，`重写锁获取或释放的条件判断的抽象方法`即可使用**；- 内部维护一个`成员变量volatile int state(共

java中模拟并发请求，自然是很方便的，只要多开几个线程，发起请求就好了。但是，这种请求，一般会`存在启动的先后顺序了`，算不得真正的同时并发！怎么样才能做到真正的同时并发呢？java中提供了`闭锁 CountDownLatch、信号量Semaphore`、`同步屏障CyclicBarrier,` 刚好就用来做这种事就最合适了。

**区别：**1. 当队列是空的时，从队列中`读元素`的操作将会被`阻塞`，**即试图从空的阻塞队列中读元素的线程将会被阻塞，直到其他的线程往空的队列写入新的元素。**2. 当队列是满时，往队列里`写元素`的操作会被`阻塞`。**即试图往已满的阻塞队列中写元素的线程同样也会被阻塞，直到其他的线程读元素使队列重新变得空闲起来。****原理:** 阻塞队列就是通过 "生产-消费者模型" 实现的，**当队列为空时，消费者挂起，队列已满时，生产者挂起**。阻塞其实就是`将线程挂起。`**场景:*

**锁机制用于保证操作的原子性、可见性、顺序性**。`JDK1.5的concurrent并发包`中新增了`Lock接口以及相关实现类来实现锁功能`，最明显的特性就是需要显式的申请锁和释放锁。比synchronized更加灵活。>显示锁的释放锁的操作一定要放到finally块中，否则可能会因为异常导致锁永远无法释放！这是显式锁最明显的缺点。

- 我们平时用`（synchronized，Lock）`都属于`悲观锁`。它总是人为`每次修改数据之前都可能被其他人(线程)修改，所以在访问资源的时候就会对资源进行加锁`。**当线程获取到锁后，其他需要锁获取锁的线程就要`阻塞`，等待持有锁的线程释放锁。**- CAS机制属于`乐观锁`，乐观锁的核心思路就是**每次不加锁而是假设修改数据之前其他线程一定不会修改，如果因为修改过产生冲突就失败就重试，直到成功为止**。CAS的全称是`Compare And Swap`，翻译过来就是`比较并交换`。是一种

**Java内置锁不需要显式的获取锁和释放锁，由JVM内部来实现锁的获取与释放。而且任何一个对象都能作为一把内置锁。在`JDK1.4`及之前就是使用`内置锁Synchronized`来进行线程同步控制的**`上文说，任何一个对象都能作为一把内置锁”，意味着synchronized关键字出现的地方，都有一个对象与之关联`，具体表现为：- 当synchronized作用于`普通方法`时，锁对象是`this`；- 当synchronized作用于`静态方法`时，锁对象是`当前类的Class对象`；-

一.缓存导致的可见性问题在多核cpu时代，cpu缓存的同步会导致共享变量的操作结果在多个线程之间不可见(线程的主内存与工作内存同步)，进而导致并发问题。int count=0；如下图若线程A和线程B同时做count+=1操作，得到的结果可能并不是我们想要的 count=2 而是count=1如果循环加 1万 次 count 的结果接近 2万而不是 2万。若循环 1亿 次效果将更明显 count 的结果接近 1亿而不是 2亿多线程对变量 V 的操作过程如下图二.线程切换导致的原子性问题我

本章主要对Java并发(Concurrent)在不同jdk版本中的发展简史进行学习。Java语言从第一版本至今，内置了对并发(Concurrent)的各种支持技术。本章先对Java个版本中的主要并发技术进行简述。

Unsafe是在`sun.misc`包下的类，`不属于Java标准`，提供了一些相对`底层方法`来操作`系统底层资源`。很多Java的基础类库，包括一些被广泛使用的高性能开发库都是基于Unsafe类开发的，比如`Netty、Cassandra、Hadoop、Kafka` 等。Unsafe类在提升Java运行效率，增强Java语言底层操作能力方面起了很大的作用。不受JVM管理，也就意味着无法被GC，需要我们`手动GC`，稍有不慎就会出现`内存泄漏` ，严重时甚至可能引起JVM崩溃。

前言上次本人是基于java1.8新特性编写了一个简单的线程池，使用了原子变量、阻塞队列、可重入锁等等新特性，内容全部收录在下面两篇文章中【Java多线程】自己实现一个简单的线程池(一)【Java多线程】自己实现一个简单的线程池(二)这次本人闲的无聊，想通过原生的java方式实现一个简单的线程池一.简易版实现流程包含功能：创建线程池，销毁线程池，添加新任务没有任务进入等待，有任务则处理掉动态伸缩，扩容拒绝策略因为自己实现的简易版本所以不建议生产中使用，生产中使用java.uti

**一个线程池包括以下四个基本组成部分：**1. 线程工厂（ThreadFactory）：用于创建并管理线程池，包括 创建线程池，销毁线程池，添加新任务；2. 工作线程（Worker）：线程池中线程，在没有任务时处于等待状态，可以循环的执行任务；3. 任务接口（Runnable）：每个任务必须实现的接口，以供工作线程调度任务的执行，它主要规定了任务的入口，任务执行完后的收尾工作，任务的执行状态等；4. 任务队列（workQueue）：用于存放待执行的任务。提供一种缓冲机制。

- **`单核CPU(单处理器)上`，只可能存在`并发`而不可能存在并行。** - **`并行在多处理器(多CPU)系统中存在，而并发可以在单处理器和多处理器系统中都存在`**，并发能够在单处理器系统中存在是因为 "并发是并行的假象"，**`并行要求程序能够同时执行多个操作`**，而 **`并发只是要求程序假装同时执行多个操作`（每个小时间片执行一个操作，多个操作快速切换执行)**- **并发是`“伪并行”`，看似并行，而实际上还是一个`CPU(单处理器)`执行一切事物，只是`切换的太快`，我们没法察觉

Fork/Join框架是`Java7`提供的一个用于`并行执行任务`的框架，可以把`大任务分割成若干个小任务`，`最终汇总每个小任务结果后得到大任务结果的框架`。可以通过Fork和Join这两个单词来理解下Fork/Join框架- **Fork**就是把一个`大任务` `切分` 为`若干子任务并行的执行`- **Join**就是`合并这些子任务的执行结果`，最后得到这个`大任务的结果`。

- 异步编程是编写`非阻塞的代码`，运行的任务`在一个单独的线程`，与`主线程隔离`，并且会`通知主线程它的进度`，`成功或者失败`。在这种方式中，`主线程不会被阻塞`，不需要一直等到子线程完成。`主线程可以并行的执行其他任务。`使用这种并行方式，可以极大的提高程序的性能。

描述 Future FutureTask CompletionService CompletableFuture原理 Future接口 接口RunnableFuture的唯一实现类，RunnableFuture接口继承自Future+Runnable 内部通过阻塞队列+FutureTask接口 JDK8实现了Future, CompletionStage两个接口多任务并发执行 支持 支持 支持 支持获取任务结果的顺序 按照提交顺序获取结果 未知 支持任务完成的先后顺序 支持任务完成的先后顺序异常捕捉

**并行**，即: `多个线程一起运行，来提高系统的整体处理速度` 。- 为什么使用多个线程就能提高处理速度，因为现在计算机普遍都是`多核处理器`，我们需要充`分利用cpu资源`；如果站的更高一点来看，我们`每台机器都可以是一个处理节点`，`多台机器并行处理`。并行的处理方式可以说无处不在。

Java中`每个对象`都有一个`唯一`与之对应的`内部锁（Monitor）`。`JVM`会为每个`Monitor`维护两个`“队列-> Entry Set 和 Wait Set” `**（姑且称之为“队列”，尽管它不一定符合数据结构上队列的“先进先出”原则）**>Entry Set和Wait Set，也有人翻译为`锁池和等待池`，意思基本一致。其实个人的理解可以认为是**就绪队列和等待队列**。- 一个叫`Entry Set（入口集）`，另外一个叫`Wait Set（等待集）`。对于任意的对象**

线程池概念有时候，系统需要处理非常多的执行时间很短的请求，如果每一个请求都开启一个新线程的话，系统就要不断的进行线程的创建和销毁，有时花在创建和销毁线程上的时间会比线程真正执行的时间还长。而且当线程数量太多时，系统不一定能受得了。概念：线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的堆栈大小，以默认的优先级运行，并处于多线程单元中。我们将任务添加到任务队列中，线程池得知有任务到来后，会唤醒线程，如若所有线程都在执行任

再看本文之前，强烈建议先查看上篇【Java多线程】自己实现一个简单的线程池(一)该文章主要实现了线程池的以下功能线程池基本调度功能。线程池自动扩容缩容。队列缓存线程。关闭线程池。这些功能，最后也留下了三个待实现的 features 。执行带有返回值的线程。异常处理怎么办？所有任务执行完怎么通知我？

线程池它就是一个调度任务的工具。他会初始化线程池会设置线程池的大小，假设我们有500个任务需要运行,而线程池的大小为10-20,在真正运行任务的过程中他肯定不会创建这500个线程同时运行,而是充分利用线程池里这10-20个线程来调度这500个任务。而这里的10-20个线程最后会由线程池封装为ThreadPoolExecutor.Worker对象,而这个Worker是实现了Runnable接口的,所以他自己本身就是一个线程。:

面试官：听说你看过ThreadLocal源码？我来瞅瞅？Java并发之ThreadLocal一文搞懂 ThreadLocal 原理Java中ThreadLocal 原理分析与使用场景ThreadLocal就是这么简单再也不学ThreadLocal了，看这一篇就忘不掉了！（万字总结）线程安全性？如何安全地使用 ThreadLocalThreadLocal 和神奇的数字 0x61c88647面试再问ThreadLocal，别说你不会ThreadLocal可以解决并发问题吗面试官再问你 Thr

关于主内存与工作内存之间的具体交互协议，即一个变量如何从主内存拷贝到工作内存、如何从工作内存同步回主内存之类的实现细节，Java 内存模型中定义了下面 8 种操作来完成。从上图可以直观的看到volatile的实现可见性的原理，线程对变量读取/写入的时候，直接从主内存中读，而不是从线程的工作内存。Assign(赋值)：作用于工作内存中的变量，把一个从执行引擎接收到的值赋值给工作内存中的变量。：作用于工作内存中的变量，把工作内存中的一个变量的值传送到主内存中，以便随后 write 操作使用。

文章目录什么是串行、并发、并行浅谈锁的作用1.锁有什么作用呢2.Java中的锁有什么作用呢3.为什么要用锁一.Java锁分类1.公平锁/非公平锁2.可重入锁/不可重入锁3.独享锁/共享锁4.互斥锁/读写锁5.乐观锁/悲观锁6.分段锁7.偏向锁/轻量级锁/重量级锁8.自旋锁8.1.简单了解一下CAS算法？CAS的问题8.2.什么是自旋锁？8.3.Java如何实现自旋锁？8.4.自旋锁存在的问题8.5...

一.多线程基础1.多任务概念现代操作系统（Windows，macOS，Linux）都可以执行多任务。多任务就是同时运行多个任务，例如：同时打开ie浏览器/QQ/QQ音乐CPU执行代码都是一条一条顺序执行的，即使是单核cpu，也可以同时运行多个任务。 因为操作系统执行多任务实际上就是让CPU对多个任务轮流交替执行。例如，假设我们有语文、数学、英语3门作业要做，每个作业需要30分钟...