Java多线程并发08——锁在Java中的应用
Java面典 人气:2
>前两篇文章中，为各位带来了，锁的类型及锁在Java中的实现。接下来本文将为各位带来锁在Java中的应用相关知识。关注我的公众号「Java面典」了解更多 Java 相关知识点。
锁在Java中主要应用还是在JUC（java.util.concurrent）包下的相关类，常用的主要有原子类、原子集合以及阻塞队列。
# 原子类（Atomicxxx）
## AtomicLong
AtomicInteger、AtomicLong 和 AtomicBoolean 这3个基本类型的原子类的原理和用法相似。
### 作用
**对 Long 进行原子操作。** 在32位操作系统中，64位的 long 和 double 变量由于会被 JVM 当作两个分离的 32 位来进行操作，所以不具有原子性。而使用 AtomicLong 能让 long 的操作保持原子型。
### 实现原理
AtomicLong 主要依赖 CAS 原理实现。以 incrementAndGet() 为例，其实现原理如下：
1. incrementAndGet() 首先会根据 get() 获取 AtomicLong 对应的 long 值；
2. incrementAndGet() 接着将 current 加 1，然后通过 CAS 函数，将新的值赋值给 value。
## AtomicIntegerArray
AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray这3个数组类型的原子类的原理和用法相似。
### 作用
AtomicLongArray 的作用则是对"长整形数组"进行原子操作。
### 实现原理
AtomicLongArray 和 AtomicLong 实现原理类似，也是依赖于 CAS 原理实现。以 addAndGet() 为例，其实现原理如下：
```java
public long addAndGet(int i, long delta) {
// 检查数组是否越界
long offset = checkedByteOffset(i);
while (true) {
// 获取long型数组的索引 offset 的原始值
long current = getRaw(offset);
// 修改long型值
long next = current + delta;
// 通过CAS更新long型数组的索引 offset的值。
if (compareAndSetRaw(offset, current, next))
return next;
}
}
```
1. 首先检查数组是否越界；
2. 若未越界，采取和 AtomcitLong 一样的方式进行值更新。
## AtomicReference
### 作用
AtomicReference 是作用是对"对象"进行原子操作。
### 实现原理
AtomicReference 是通过"volatile"和"Unsafe提供的CAS函数实现"原子操作。其实现原理如下：
1. 首先 AtomicReference 类的 value 是 volatile 类型。这保证了：当某线程修改 value 的值时，其他线程看到的 value 值都是最新的 value 值，即修改之后的 volatile 的值；
2. 通过 CAS 设置 value。这保证了：当某线程池通过 CAS 函数(如 compareAndSet 函数)设置 value 时，它的操作是原子的，即线程在操作 value 时不会被中断。
## AtomicIntegerFieldUpdater
AtomicIntegerFieldUpdater、AtomicLongFieldUpdater、AtomicReferenceFieldUpdater 这 3 个修改类的成员的原子类型的原理和用法相似。
### 作用
AtomicLongFieldUpdater 可以对指定"类的 'volatile long'类型的成员"进行原子更新。它是基于反射原理实现的。
### 实现原理
以 newUpdater() 为例，其实现原理如下：
```java
public static AtomicLongFieldUpdater newUpdater(Class tclass, String fieldName) {
Class<?> caller = Reflection.getCallerClass();
if (AtomicLong.VM_SUPPORTS_LONG_CAS)
return new CASUpdater(tclass, fieldName, caller);
else
return new LockedUpdater(tclass, fieldName, caller);
}
```
1. newUpdater() 实际上返回的是CASUpdater对象，或者LockedUpdater对象；
2. 具体返回哪一个类取决于 JVM 是否支持 long 类型的 CAS 函数;
3. CASUpdater 和 LockedUpdater 都是 AtomicIntegerFieldUpdater 的子类，它们的实现类似。
# 原子集合（CopyOnWritexxx、Concurrentxxx）
## CopyOnWriteArrayList
CopyOnWriteArrayList 与 CopyOnWriteArraySet 的作用类似，不过一个是动态数组，一个是散列表，其实现原理类似。
### 作用
CopyOnWriteArrayList 相当于线程安全的 ArrayList 。
### 实现原理
**动态数组实现**：
1. 在其内部有个“volatile数组”(array)来存储数据；
2. 在“添加/修改/删除”数据时，都会新建一个数组，并将更新后的数据拷贝到新建的数组中;
3. 最后再将该数组赋值给“volatile数组”。
**线程安全实现**:
CopyOnWriteArrayList 的线程安全是通过 volatile 和互斥锁来实现的。
1. CopyOnWriteArrayList 是通过“volatile数组”来保存数据的。一个线程读取volatile数组时，总能看到其它线程对该 volatile 变量最后的写入；就这样，通过 volatile 提供了“读取到的数据总是最新的”这个机制的保证。
2. CopyOnWriteArrayList 通过互斥锁来保护数据。在“添加/修改/删除”数据时，会先“获取互斥锁”，再修改完毕之后，先将数据更新到“volatile数组”中，然后再“释放互斥锁”；这样，就达到了保护数据的目的。
### CopyOnWriteArrayList 与 ArrayList 区别
1. CopyOnWriteArrayList 是线程安全的；
2. 因为通常需要复制整个基础数组，所以可变操作（add()、set() 和 remove() 等等）的开销很大；
3. 迭代器支持 hasNext()，next() 等不可变操作，但不支持可变 remove() 等操作；
4. 使用迭代器进行遍历的速度很快，并且不会与其他线程发生冲突。在构造迭代器时，迭代器依赖于不变的数组快照。
### 适用范围
CopyOnWriteArrayList 最适合于具有以下特征的应用程序：
1. List 大小通常保持很小；
2. 只读操作远多于可变操作；
3. 需要在遍历期间防止线程间的冲突。
## ConcurrentHashMap
与 ConcurrentHashMap 类似的还有 ConcurrentSkipListMap、ConcurrentSkipListSet。ConcurrentHashMap 的实现原理可以在我往期的文章中查看。[ConcurrentHashMap 传送门](https://www.jianshu.com/p/e70edcd4e7d1)
# 阻塞队列（xxxQueue）
## 阻塞情况
在阻塞队列中，队列阻塞有这样的两种情况：
1. **当队列中没有数据的情况下**，消费者端的所有线程都会被自动阻塞（挂起），直到有数据放入队列；
2. **当队列中填满数据的情况下**，生产者端的所有线程都会被自动阻塞（挂起），直到队列中有空的位置，线程被自动唤醒。
## 常用方法
方法类型 | 抛出异常 | 特殊值 | 阻塞 | 超时
:------------: | :----------: | :--------: | :--------: | :------------------------:
插入 | add(e) | offer(e) | put(e) | offer(e, time, unit) |
移除 | remove() | poll() | take() | pull(time, uinit) |
检查 | element()| peek() | 不可用 | 不可用 |
* 抛出异常：抛出一个异常；
* 特殊值：返回一个特殊值（null 或 false，视情况而定）；
* 则塞：在成功操作之前，一直阻塞线程；
* 超时：放弃前只在最大的时间内阻塞。
## ArrayBlockingQueue（公平、非公平）
**本质**：用数组实现的有界阻塞队列。
**特点**
1. 此队列按照先进先出（FIFO）的原则对元素进行排序；
2. 默认情况下不保证访问者公平的访问队列；
3. 公平访问队列是指阻塞的所有生产者线程或消费者线程，当队列可用时，可以按照阻塞的先后顺序访问队列;
4. 通常情况下为了保证公平性会降低吞吐量。
```java
// 创建一个公平的阻塞队列
ArrayBlockingQueue fairQueue = new ArrayBlockingQueue(1000,true);
```
## LinkedBlockingQueue（两个独立锁提高并发）
**本质**：由链表结构组成的有界阻塞队列，与 ArrayListBlockingQueue 类似。
**特点**
1. 此队列按照先进先出（FIFO）的原则对元素进行排序；
2. 对于生产者端和消费者端分别采用了独立的锁来控制数据同步，在高并发的情况下生产者和消费者可以并行地操作队列中的数据，以此来提高整个队列的并发性能；
3. LinkedBlockingQueue 会默认一个类似无限大小的容量（Integer.MAX_VALUE）。
## PriorityBlockingQueue（compareTo 排序实现优先）
**本质**：支持优先级排序的无界阻塞队列。
**特点**
1. 默认情况下元素采取自然顺序升序排列；
2. 可以自定义实现 compareTo() 方法来指定元素进行排序规则，或者初始化 PriorityBlockingQueue 时，指定构造参数 Comparator 来对元素进行排序。
**`PriorityBlockingQueue 不能保证同优先级元素的顺序。`**
## DelayQueue（缓存失效、定时任务 ）
**本质**：使用优先级队列实现的无界阻塞队列。
**特点**
1. 队列使用 PriorityQueue 来实现；
2. 队列中的元素必须实现 Delayed 接口，在创建元素时可以指定多久才能从队列中获取当前元素。只有在延迟期满时才能从队列中提取元素。
**适用场景**
1. **缓存系统的设计**：可以用 DelayQueue 保存缓存元素的有效期，使用一个线程循环查询 DelayQueue，一旦能从 DelayQueue 中获取元素时，表示缓存有效期到了。
2. **定时任务调度**：使用 DelayQueue 保存当天将会执行的任务和执行时间，一旦从 DelayQueue 中获取到任务就开始执行，从比如 TimerQueue 就是使用 DelayQueue 实现的。
## SynchronousQueue（不存储数据、可用于传递数据）
**本质**：不存储元素的阻塞队列。
**特点**
1. 每一个 put 操作必须等待一个 take 操作，否则不能继续添加元素;
2. 队列本身并不存储任何元素，只是负责把生产者线程处理的数据直接传递给消费者线程。
**适用场景**
适合于传递性场景，比如在一个线程中使用的数据，传递给另外一个线程使用。
**`SynchronousQueue 的吞吐量高于 LinkedBlockingQueue 和 ArrayBlockingQueue。`**
## LinkedTransferQueue
**本质**：由链表结构组成的无界阻塞队列。
**特点**
相对于其他阻塞队列，LinkedTransferQueue 多了 tryTransfer 和 transfer 方法。
1. transfer 方法：如果当前有消费者正在等待接收元素（消费者使用 take()方法或带时间限制的poll()方法时），transfer 方法可以把生产者传入的元素立刻 transfer（传输）给消费者。如果没有消费者在等待接收元素，transfer 方法会将元素存放在队列的 tail 节点，并等到该元素被消费者消费了才返回。
2. tryTransfer 方法。则是用来试探下生产者传入的元素是否能直接传给消费者。如果没有消费者等待接收元素，则返回 false。对于带有时间限制的 tryTransfer(E e, long timeout, TimeUnit unit)方法，则是试图把生产者传入的元素直接传给消费者，但是如果没有消费者消费该元素则等待指定的时间再返回，如果超时还没消费元素，则返回 false，如果在超时时间内消费了元素，则返回 true。
**`和 transfer 方法的区别是 tryTransfer 方法无论消费者是否接收，方法立即返回。而 transfer 方法是必须等到消费者消费了才返回。`**
## LinkedBlockingDeque
**本质**：由链表结构组成的双向阻塞队列。
**特点**
1. 可以从队列的两端插入和移出元素；
2. 双端队列因为多了一个操作队列的入口，在多线程同时入队时，也就减少了一半的竞争；
3. 相比其他的阻塞队列，LinkedBlockingDeque 多了 addFirst，addLast，offerFirst，offerLast，peekFirst，peekLast 等方法。
# 多线程与并发系列推荐
**[Java多线程并发07——锁在Java中的实现](https://www.cnblogs.com/weechang/p/12542843.html)**
**[Java多线程并发06——CAS与AQS](https://www.cnblogs.com/weechang/p/12545271.html)**
**[Java多线程并发05——那么多的锁你都了解了吗](https://www.cnblogs.com/weechang/p/12539361.html)**
**[Java多线程并发04——合理使用线程池](https://www.cnblogs.com/weechang/p/12527425.html)**
**[Java多线程并发03——什么是线程上下文，线程是如何调度的](https://www.cnblogs.com/weechang/p/12520252.html)**
**[Java多线程并发02——线程的生命周期与常用方法，你都掌握了吗](https://www.cnblogs.com/weechang/p/12507989.html)**
**[Java多线程并发01——线程的创建与终止，你会几种方式](https://www.cnblogs.com/weechang/p/12499987.html)**
加载全部内容