前言

Java中的大部分同步类（Lock、Semaphore、ReentrantLock等）都是基于AbstractQueuedSynchronizer（简称为AQS）实现的。AQS是一种提供了原子式管理同步状态、阻塞和唤醒线程功能以及队列模型的简单框架。本文会从应用层逐渐深入到原理层，并通过ReentrantLock的基本特性和ReentrantLock与AQS的关联，来深入解读AQS相关独占锁的知识点，同时采取问答的模式来帮助大家理解AQS。由于篇幅原因，本篇文章主要阐述AQS中独占锁的逻辑和Sync Queue，不讲述包含共享锁和Condition Queue的部分（本篇文章核心为AQS原理剖析，只是简单介绍了ReentrantLock，感兴趣同学可以阅读一下ReentrantLock的源码）。

下面列出本篇文章的大纲和思路，以便于大家更好地理解：

日常的操作中，增删改查都会使用什么类型的锁？其实这个问题，可以分为两个方面，一方面是读，一方面是写。

读（select）

我们先来看读的部分。读的操作，其实分为两种，分别是一致性读和锁定读，

这里我们温习一下，一致性读其实就是利用事务的MVCC机制，来读取一份数据的快照，所以有的书上也称之为快照读，一致性读是不加锁的，其他的事务是可以对表中的数据记录进行改动的。一般情况下，常见的读，例如：

select * from table；

select * from table left join table2;

这种操作，在RU，RC，RR隔离级别下都是采用一直性读，不加锁的操作。这种情况下，读的并发可以非常高。

再来看看锁定读，如果我们的表当中有索引，我们想在读取记录的时候，获取某一条记录的锁，禁止别的事务对这条记录进行修改，那么我们可以使用下面的语句来对读取的记录加锁：

服务异常的处理流程

操作系统概念

大部分操作系统提供了特定的基础概念和抽象，例如进程、地址空间、文件等，它们是需要理解的核心内容。下面我们会简要介绍一些基本概念，为了说明这些概念，我们会不时的从 UNIX 中提出示例，相同的示例也会存在于其他系统中，我们后面会进行介绍。

并发容器介绍

1. ConcurrentHashMap：并发版HashMap
2. CopyOnWriteArrayList：并发版ArrayList
3. CopyOnWriteArraySet：并发Set
4. ConcurrentLinkedQueue：并发队列(基于链表)
5. ConcurrentLinkedDeque：并发队列(基于双向链表)
6. ConcurrentSkipListMap：基于跳表的并发Map
7. ConcurrentSkipListSet：基于跳表的并发Set
8. ArrayBlockingQueue：阻塞队列(基于数组)
9. LinkedBlockingQueue：阻塞队列(基于链表)
10. LinkedBlockingDeque：阻塞队列(基于双向链表)
11. PriorityBlockingQueue：线程安全的优先队列
12. SynchronousQueue：读写成对的队列
13. LinkedTransferQueue：基于链表的数据交换队列
14. DelayQueue：延时队列

1.ConcurrentHashMap 并发版HashMap

最常见的并发容器之一，可以用作并发场景下的缓存。底层依然是哈希表，但在JAVA 8中有了不小的改变，而JAVA 7和JAVA 8都是用的比较多的版本，因此经常会将这两个版本的实现方式做一些比较（比如面试中）

一个比较大的差异就是，JAVA 7中采用分段锁来减少锁的竞争，JAVA 8中放弃了分段锁，采用CAS，同时为了防止哈希冲突严重时退化成链表（冲突时会在该位置生成一个链表，哈希值相同的对象就链在一起），会在链表长度达到阈值（8）后转换成红黑树（比起链表，树的查询效率更稳定）。

2.CopyOnWriteArrayList 并发版ArrayList

并发版ArrayList，底层结构也是数组，和ArrayList不同之处在于：当新增和删除元素时会创建一个新的数组，在新的数组中增加或者排除指定对象，最后用新增数组替换原来的数组。

适用场景：由于读操作不加锁，写（增、删、改）操作加锁，因此适用于读多写少的场景。

局限：由于读的时候不会加锁（读的效率高，就和普通ArrayList一样），读取的当前副本，因此可能读取到脏数据。如果介意，建议不用。

看看源码感受下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

public class CopyOnWriteArrayList<E>
  implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
  final transient ReentrantLock lock = new ReentrantLock();
  private transient volatile Object[] array;
  // 添加元素，有锁
  public boolean add(E e) {
    final ReentrantLock lock = this.lock;
    lock.lock(); // 修改时加锁，保证并发安全
    try {
      Object[] elements = getArray(); // 当前数组
      int len = elements.length;
      Object[] newElements = Arrays.copyOf(elements, len + 1); // 创建一个新数组，比老的大一个空间
      newElements[len] = e; // 要添加的元素放进新数组
      setArray(newElements); // 用新数组替换原来的数组
      return true;
    } finally {
      lock.unlock(); // 解锁
    }
  }
  // 读元素，不加锁，因此可能读取到旧数据
  public E get(int index) {
    return get(getArray(), index);
  }
}

3.CopyOnWriteArraySet 并发Set

基于CopyOnWriteArrayList实现（内含一个CopyOnWriteArrayList成员变量），也就是说底层是一个数组，意味着每次add都要遍历整个集合才能知道是否存在，不存在时需要插入（加锁）。

适用场景：在CopyOnWriteArrayList适用场景下加一个，集合别太大（全部遍历伤不起）。

4.ConcurrentLinkedQueue 并发队列(基于链表)

基于链表实现的并发队列，使用乐观锁(CAS)保证线程安全。因为数据结构是链表，所以理论上是没有队列大小限制的，也就是说添加数据一定能成功。

5.ConcurrentLinkedDeque 并发队列(基于双向链表)

基于双向链表实现的并发队列，可以分别对头尾进行操作，因此除了先进先出(FIFO)，也可以先进后出（FILO），当然先进后出的话应该叫它栈了。

6.ConcurrentSkipListMap 基于跳表的并发Map

SkipList即跳表，跳表是一种空间换时间的数据结构，通过冗余数据，将链表一层一层索引，达到类似二分查找的效果

7.ConcurrentSkipListSet 基于跳表的并发Set

类似HashSet和HashMap的关系，ConcurrentSkipListSet里面就是一个ConcurrentSkipListMap，就不细说了。

8.ArrayBlockingQueue 阻塞队列(基于数组)

基于数组实现的可阻塞队列，构造时必须制定数组大小，往里面放东西时如果数组满了便会阻塞直到有位置（也支持直接返回和超时等待），通过一个锁ReentrantLock保证线程安全。

用offer操作举个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

public class ArrayBlockingQueue<E> extends AbstractQueue<E>
  implements BlockingQueue<E>, java.io.Serializable {
  /**
   * 读写共用此锁，线程间通过下面两个Condition通信
   * 这两个Condition和lock有紧密联系（就是lock的方法生成的）
   * 类似Object的wait/notify
   */
  final ReentrantLock lock;
  /** 队列不为空的信号，取数据的线程需要关注 */
  private final Condition notEmpty;
  /** 队列没满的信号，写数据的线程需要关注 */
  private final Condition notFull;
  // 一直阻塞直到有东西可以拿出来
  public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
      while (count == 0)
        notEmpty.await();
      return dequeue();
    } finally {
      lock.unlock();
    }
  }
  // 在尾部插入一个元素，队列已满时等待指定时间，如果还是不能插入则返回
  public boolean offer(E e, long timeout, TimeUnit unit)
  throws InterruptedException {
    checkNotNull(e);
    long nanos = unit.toNanos(timeout);
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly(); // 锁住
    try {
      // 循环等待直到队列有空闲
      while (count == items.length) {
        if (nanos <= 0)
          return false;// 等待超时，返回
        // 暂时放出锁，等待一段时间（可能被提前唤醒并抢到锁，所以需要循环判断条件）
        // 这段时间可能其他线程取走了元素，这样就有机会插入了
        nanos = notFull.awaitNanos(nanos);
      }
      enqueue(e);//插入一个元素
      return true;
    } finally {
      lock.unlock(); //解锁
    }
  }
}

乍一看会有点疑惑，读和写都是同一个锁，那要是空的时候正好一个读线程来了不会一直阻塞吗？

答案就在notEmpty、notFull里，这两个出自lock的小东西让锁有了类似synchronized + wait + notify的功能。

9.LinkedBlockingQueue 阻塞队列(基于链表)

基于链表实现的阻塞队列，想比与不阻塞的ConcurrentLinkedQueue，它多了一个容量限制，如果不设置默认为int最大值。

10.LinkedBlockingDeque 阻塞队列(基于双向链表)

类似LinkedBlockingQueue，但提供了双向链表特有的操作。

11.PriorityBlockingQueue 线程安全的优先队列

构造时可以传入一个比较器，可以看做放进去的元素会被排序，然后读取的时候按顺序消费。某些低优先级的元素可能长期无法被消费，因为不断有更高优先级的元素进来。

12.SynchronousQueue 数据同步交换的队列

一个虚假的队列，因为它实际上没有真正用于存储元素的空间，每个插入操作都必须有对应的取出操作，没取出时无法继续放入。

一个简单的例子感受一下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

import java.util.concurrent.*;
public class Main {
  public static void main(String[] args) {
    SynchronousQueue<Integer> queue = new SynchronousQueue<>();
    new Thread(() -> {
      try {
        // 没有休息，疯狂写入
        for (int i = 0; ; i++) {
          System.out.println("放入: " + i);
          queue.put(i);
        }
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }).start();
    new Thread(() -> {
      try {
        // 咸鱼模式取数据
        while (true) {
          System.out.println("取出: " + queue.take());
          Thread.sleep((long) (Math.random() * 2000));
        }
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }).start();
  }
}
/* 输出:
放入: 0
取出: 0
放入: 1
取出: 1
放入: 2
取出: 2
放入: 3
取出: 3
*/

可以看到，写入的线程没有任何sleep，可以说是全力往队列放东西，而读取的线程又很不积极，读一个又sleep一会。输出的结果却是读写操作成对出现。

JAVA中一个使用场景就是Executors.newCachedThreadPool()，创建一个缓存线程池。

1
2
3
4
5
6
7

public static ExecutorService newCachedThreadPool() {
  return new ThreadPoolExecutor(
             0, // 核心线程为0，没用的线程都被无情抛弃
             Integer.MAX_VALUE, // 最大线程数理论上是无限了，还没到这个值机器资源就被掏空了
             60L, TimeUnit.SECONDS, // 闲置线程60秒后销毁
             new SynchronousQueue<Runnable>()); // offer时如果没有空闲线程取出任务，则会失败，线程池就会新建一个线程
}

13.LinkedTransferQueue 基于链表的数据交换队列

实现了接口TransferQueue，通过transfer方法放入元素时，如果发现有线程在阻塞在取元素，会直接把这个元素给等待线程。如果没有人等着消费，那么会把这个元素放到队列尾部，并且此方法阻塞直到有人读取这个元素。和SynchronousQueue有点像，但比它更强大。

14.DelayQueue 延时队列

可以使放入队列的元素在指定的延时后才被消费者取出，元素需要实现Delayed接口。

总结

上面简单介绍了JAVA并发包下的一些容器类，知道有这些东西，遇到合适的场景时就能想起有个现成的东西可以用了。想要知其所以然，后续还得再深入探索一番。

Optional

Optional是一个评价过低的特性，它可以显著的降低代码抛出NullPointerException的可能。它在边界代码(你正在使用的API或者你发布的API)中特别有用。

但是对于它的不适当的使用和设计很容易使一个小的变动影响到很多的类，或者降低代码的可阅读性。这里有一些如何更加高效使用Optional的建议。

以下内容为入门级介绍，意在对老技术作较全的总结而不是较深的研究。主要参考《构建高性能Web站点》一书。

什么是服务器并发处理能力

一台服务器在单位时间里能处理的请求越多，服务器的能力越高，也就是服务器并发处理能力越强

概念

模型

节点

在具体的工程项目中，一个节点往往是一个操作系统上的进程。在本文的模型中，认为节点是一个完整的、不可分的整体，如果某个程序进程实际上由若干相对独立部分构成，则在模型中可以将一个进程划分为多个节点。

以下文章来源于Java建设者 ，作者cxuan

HTTP 内容协商

什么是内容协商

在 HTTP 中，内容协商是一种用于在同一 URL 上提供资源的不同表示形式的机制。内容协商机制是指客户端和服务器端就响应的资源内容进行交涉，然后提供给客户端最为适合的资源。内容协商会以响应资源的语言、字符集、编码方式等作为判断的标准。

相关文档

官方文档

Github地址

语句末尾分号是可选的。%% 行注释。

流程图

语法说明

图表方向

Mermaid 支持多种图表的方向，语法如下：

1
2

graph 方向描述
    图表中的其他语句...

其中“方向描述”为

节点定义

即流程图中每个文本块，包括开始、结束、处理、判断等。Mermaid 中每个节点都有一个 id，以及节点的文字。

需要注意的是，如果节点的文字中包含标点符号，需要时用双引号包裹起来。
另外如果希望在文字中使用换行，请使用
替换换行

节点间的连线

子图表

使用以下语法添加子图表

1
2
3

subgraph 子图表名称
    子图表中的描述语句...
end123

对 font awesome 的支持

使用 fa: #图表名称# 的语法添加 fontawesome。

1
2
3
4
5

graph TD;
    A-->B;
    A-->C;
    B-->D;
    C-->D;

方向

• TB/TD - top bottom
• BT - bottom top
• RL - right left
• LR - left right

1
2

graph TB
    Start --> Stop

节点

1
2

graph LR
    id

1
2

graph LR
    id[带文字节点]

1
2

graph LR
    id(圆角节点)

1
2

graph LR
    id((圆形节点))

1
2

graph LR
    id>不对称节点]

1
2

graph LR
    id{菱形节点}

连接线

实线，箭头，无文字

1
2

graph LR
    A-->B

实线，无箭头，无文字

1
2

graph LR
    A---B

实线，无箭头，文字

前面两个 -，后面三个 -

1
2

graph LR
    A-- 文字 ---B

或

1
2

graph LR
    A--- |文字| B

实线，箭头，文字

1
2

graph LR
    A-- 文字 -->B

或

1
2

graph LR
    A--> |文字| B

虚线，箭头，无文字

1
2

graph LR;
   A-.->B;

虚线，箭头，文字

1
2

graph LR
   A-. text .-> B

大箭头，无文字

1
2

graph LR
   A ==> B

大箭头，文字

1
2

graph LR
   A == text ==> B

特殊语法

引号

文字里用引号避免一些特殊字符的错误。比如矩形节点里有 () 时就无法渲染，所以加上引号。

1
2

graph LR
    id1["This is the (text) in the box"]

实体字符

可以使用 HTML 中的实体字符。

1
2

graph LR
     A["A double quote:#quot;"] -->B["A dec char:#9829;"]

子图

1
2
3
4
5
6
7
8
9
10
11

graph TB
    c1-->a2
    subgraph one
    a1-->a2
    end
    subgraph two
    b1-->b2
    end
    subgraph three
    c1-->c2
    end

样式

linkStyle 后面的数字表示第几根线，从 0 开始。可以指定颜色和粗细。

1
2
3
4
5
6
7

graph TD;
    A-->B;
    A-->C;
    B-->D;
    C-->D;
    linkStyle 0 stroke:#0ff,stroke-width:2px;
    linkStyle 3 stroke:#ff3,stroke-width:4px;

可以设置节点背景，边框颜色，粗细，实线还是虚线

1
2
3
4

graph LR
    id1(Start)-->id2(Stop)
    style id1 fill:#f9f,stroke:#333,stroke-width:4px
    style id2 fill:#ccf,stroke:#f66,stroke-width:2px,stroke-dasharray: 5, 5

样式类

1
2
3
4
5
6
7
8

graph LR
    A-->B

    %% 定义样式类
    classDef className fill:#f9f,stroke:#333,stroke-width:4px;

    %% 应用样式类，markdown里没效果
    class A className

1

classDef default fill:#f9f,stroke:#333,stroke-width:4px;

定义一个名为 default 的类，节点没有指定特定样式类时，将都会应用这个样式类。

图标

可以使用 Font Awesome 图标。语法 fa:icon class name。

1
2
3
4
5

graph TD
   B["fa:fa-twitter for peace"]
   B-->C[fa:fa-ban forbidden]
   B-->D(fa:fa-spinner);
   B-->E(A fa:fa-camera-retro perhaps?);

时序图

1
2
3
4
5
6
7
8
9
10
11

sequenceDiagram
    participant Alice
    participant Bob
    Alice->John: Hello John, how are you?
    loop Healthcheck
        John->John: Fight against hypochondria
    end
    Note right of John: Rational thoughts <br/>prevail...
    John-->Alice: Great!
    John->Bob: How about you?
    Bob-->John: Jolly good!

参与者

如果不显示声明，参与者将根据第一次出现的顺序排列，如：

1
2
3

sequenceDiagram
    Alice->>John: Hello John, how are you?
    John-->>Alice: Great!

第一条语句出现了两个参与者角色，而在这条语句中，Alice 在 John 之前，所以图中也是这个顺序。如果不想根据第一次出现的顺序来排，可以主动声明以定义顺序：

1
2
3
4
5

sequenceDiagram
    participant John
    participant Alice
    Alice->>John: Hello John, how are you?
    John-->>Alice: Great!

别名

可以给角色写一个简短的别名以方便书写。

1
2
3
4
5

sequenceDiagram
    participant A as Alice
    participant J as John
    A->>J: Hello John, how are you?
    J->>A: Great!

消息

消息连线有六种样式。

有一个-是实线，两个-是虚线。

1
2
3
4
5
6
7

sequenceDiagram
    A->B: 无箭头实线
    A-->B: 无箭头虚线(点线)
    A->>B: 有箭头实线
    A-->>B: 有箭头实线
    A-x B: 有箭头实线，加上叉
    A--x B: 有箭头虚线，加上叉

活动期

1
2
3
4
5
6
7

sequenceDiagram
    Alice->>John: Hello John, how are you?
    %% activate 角色名 表示激活控制焦点
    activate John
    John-->>Alice: Great!
    %% deactivate 角色名 表示控制焦点结束
    deactivate John

使用 +/- 的更方便的写法：

1
2
3

sequenceDiagram
    Alice->>+John: Hello John, how are you?
    John-->>-Alice: Great!

可以嵌套：

1
2
3
4
5

sequenceDiagram
    Alice->>+John: Hello John, how are you?
    Alice->>+John: John, can you hear me?
    John-->>-Alice: Hi Alice, I can hear you!
    John-->>-Alice: I feel great!

备注

语法：Note [ right of | left of | over ] [Actor]。

1
2
3

sequenceDiagram
    participant John
    Note right of John: Text in note

over 可用于单独一个角色上，也可以用于相邻两个角色间：

1
2
3

sequenceDiagram
    Alice->John: Hello John, how are you?
    Note over Alice,John: A typical interaction

循环

语法：

1
2
3
4
5
6
7
8
9
10

loop Loop text
... statements ...
end
sequenceDiagram
    Alice->John: Hello John, how are you?
    %% loop 后跟循环体说明文字
    loop Every minute
        John-->Alice: Great!
    %% 标记循环结束
    end

选择

语法：

1
2
3
4
5

alt Describing text
... statements ...
else
... statements ...
end

可选条件，比如在没有 else 分支的情况下使用，有点类似 java 中的 switch 的 default 分支，代表剩下所有情况。

1
2
3
4
5
6
7
8
9
10
11
12
13

opt Describing text
... statements ...
end
sequenceDiagram
    Alice->>Bob: Hello Bob, how are you?
    alt is sick
        Bob->>Alice: Not so good :(
    else is well
        Bob->>Alice: Feeling fresh like a daisy
    end
    opt Extra response
        Bob->>Alice: Thanks for asking
    end