Java多线程并发08——锁在Java中的应用

前两篇文章中，为各位带来了，锁的类型及锁在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() 为例，其实现原理如下：

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() 为例，其实现原理如下：

public static <U> AtomicLongFieldUpdater<U> newUpdater(Class<U> tclass, String fieldName) {
    Class<?> caller = Reflection.getCallerClass();
    if (AtomicLong.VM_SUPPORTS_LONG_CAS)
        return new CASUpdater<U>(tclass, fieldName, caller);
    else
        return new LockedUpdater<U>(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 传送门

阻塞队列（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. 通常情况下为了保证公平性会降低吞吐量。

// 创建一个公平的阻塞队列
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中的实现

Java多线程并发06——CAS与AQS

Java多线程并发05——那么多的锁你都了解了吗

Java多线程并发04——合理使用线程池

Java多线程并发03——什么是线程上下文，线程是如何调度的

Java多线程并发02——线程的生命周期与常用方法，你都掌握了吗

Java多线程并发01——线程的创建与终止，你会几种方式