10 JUC之集合（一）

最新推荐文章于 2024-04-26 19:11:46 发布

liulimoyu

最新推荐文章于 2024-04-26 19:11:46 发布

阅读量525

点赞数

分类专栏：学习记录文章标签： java 算法数据结构

本文链接：https://blog.csdn.net/liulimoyu/article/details/127779814

版权

学习记录专栏收录该内容

31 篇文章 0 订阅

订阅专栏

CopyOnWriteArrayList

实现List接口，内部有个ReentrantLock，底层是个对象数组。

final transient ReentrantLock lock = new ReentrantLock();

private transient volatile Object[] array;

通过构造方法创建对象时，数组长度为0，没有可指定数组长度的参数。

对外的方法实现里，都通过lock先加锁，处理完毕后再释放锁。

添加数据时，会先创建一个当前数组长度+1的新数组。然后把旧数组数据copy到新数组，把新数据copy到新数组的末位索引位置。

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();
    }
}

CopyOnWriteArrayList的元素个数和数组长度保持一致，新数组的长度也只是根据本次新增加或者删除的数据个数进行动态调整。

CopyOnWriteArraySet

继承Abstract抽象类，底层实现使用了被final修饰的CopyOnWriteArrayList类，所有对外的方法，最终都转移到了CopyOnWriteArrayList里去实现了。

private final CopyOnWriteArrayList<E> al;

public CopyOnWriteArraySet() {
    al = new CopyOnWriteArrayList<E>();
}

数据的添加方法add，实际上执行的是CopyOnWriteArrayList里的addIfAbsent方法。

public boolean add(E e) {
    return al.addIfAbsent(e);
}

CopyOnWriteArrayList里的addIfAbsent方法在处理的时候，会先通过indexOf方法遍历数组，查看当前要添加的数据是否已在列表中。不存在时才执行私有的addIfAbsent方法。这个私有方法内部有一个当前数组的判断，因为这个类支持并发，有可能当前的数组已被修改过了。那么就要对比下新的数组里如果已有该对象了就不处理，没有的话才把这个数据添加到再次新创建的数组尾部。

private static int indexOf(Object o, Object[] elements,
                           int index, int fence) {
    if (o == null) {
        for (int i = index; i < fence; i++)
            if (elements[i] == null)
                return i;
    } else {
        for (int i = index; i < fence; i++)
            if (o.equals(elements[i]))
                return i;
    }
    return -1;
}

public boolean addIfAbsent(E e) {
    Object[] snapshot = getArray();
    return indexOf(e, snapshot, 0, snapshot.length) >= 0 ? false :
        addIfAbsent(e, snapshot);
}

private boolean addIfAbsent(E e, Object[] snapshot) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] current = getArray();
        int len = current.length;
        if (snapshot != current) {
            // Optimize for lost race to another addXXX operation
            int common = Math.min(snapshot.length, len);
            for (int i = 0; i < common; i++)
                if (current[i] != snapshot[i] && eq(e, current[i]))
                    return false;
            if (indexOf(e, current, common, len) >= 0)
                    return false;
        }
        Object[] newElements = Arrays.copyOf(current, len + 1);
        newElements[len] = e;
        setArray(newElements);
        return true;
    } finally {
        lock.unlock();
    }
}

ConcurrentLinkedQueue

继承AbstractQueue，实现Queue接口。是一个基于链接节点的无限线程安全队列。

ConcurrentLinkedQueue有个内部类Node，这也是队列的实现方式。队列是由Node对象组成的单向链表。链表的head和tail会一直暴露出来的。

Node类里的方法，都是通过Unsafe类进行CAS操作的。

新元素被插入队列的尾部，队列检索操作获得队列头部的元素。

队列通过add、offer方法等添加数据，通过poll、peek方法获取队列里的元素。

确定队列元素的方法，size，实现方式是通过遍历整个队列，并跳过元素为null的。别的线程可能会修改结合中元素，会导致返回的结果和实际的有可能不一样。

ArrayBlockingQueue

继承AbstractQueue，实现BlockQueue接口。是一个基于数组有界的，但是也可以是无限元素的队列。

有界是因为底层是数组，数组本身就是有界的。无限元素这个情况指的是对于数据的获取和添加，是通过索引去确定的。在队列数据被添加和获取时，索引在数组上做的是从开始到末端的循环运动。

/** 队列元素放在数组里 */
final Object[] items;

/** 下一个被获取元素的数组索引位置 */
int takeIndex;

/** 下一个被添加数据的数组索引位置 */
int putIndex;

/** 当前数组里的元素个数*/
int count;

/** 所有对外方法要使用的锁 */
final ReentrantLock lock;

/** 等待获取数据的条件 */
private final Condition notEmpty;

/** 等待添加数据的条件 */
private final Condition notFull;

构造方法

public ArrayBlockingQueue(int capacity)
public ArrayBlockingQueue(int capacity, boolean fair)
public ArrayBlockingQueue(int capacity, boolean fair, Collection<? extends E> c)

使用构造方法创建ArrayBlockingQueue对象，必须要设定队列容量，也就是数组长度。同时也可以设置队列使用公平或非公平锁。

ArrayBlockingQueue内部使用了一个ReentrantLock，这就导致对于队列进行元素添加和获取，都会使用这一套锁机制。那么如果添加元素的线程获取到了锁，那么消费元素的线程就只能等待了。反之消费线程获取到了锁，添加线程就要等待。

在通过构造方法传入一个集合时，要保证队列容量是不小于集合里元素个数的，否则会因数组越界抛出异常。

队列添加数据

public boolean add(E e)
public boolean offer(E e)
public boolean offer(E e, long timeout, TimeUnit unit) throws InterruptedException
public void put(E e) throws InterruptedException

通过offer方法添加数据时，如果当前队列数据已满（数组已满），那么添加数据就返回false，否则就做数的添加。

add的方法本质也是调用offer方法，不过会对返回结果进行判断，如果返回了false，就抛出“Queue Full”异常。

使用put方法给队列添加数据，如果当前队列已满，那么put方法就进入到while循环，添加进入到了等待状态。

数据添加成功，也就是给putIndex对应的数组位置添加了数据；putIndex对应的要进行+1，如果加1后等于数组长度，那么putIndex重新设置为0；数组里元素个数加一。

队列消费数据

public E poll()
public E poll(long timeout, TimeUnit unit) throws InterruptedException
public E take() throws InterruptedException 
public E peek()

peek方法只是从队列里获得元素，但是并没有移除该元素。所以多次peek操作得到的都是同一个元素。

take方法会在队列无元素时处于等待状态，直到有元素了才去获取并移除元素。

poll方法在队列无元素时返回null，有元素时会获取并移除元素。

元素移除对应的是takeIndex对应的索引位置被设置为null，同时takeIndex加1。当takeIndex累加结果等于数组长度，那么takeIndex设置为0，从数组头部开始又一轮循环。

LinkedBlockingQueue

继承AbstractQueue，实现BlockQueue接口。是一个有界的、链式队列。

通过内部类Node来封装放入的元素，并指向下一个Node对象。

static class Node<E> {
    E item;
    Node<E> next;
    Node(E x) { item = x; }
}
/** 队列的元素个数，最大为Integer.MAX_VALUE */
private final int capacity;
/** 当前队列里的元素个数 */
private final AtomicInteger count = new AtomicInteger();
/** 队列的头节点 */
transient Node<E> head;
/** 队列的尾节点 */
private transient Node<E> last;

/** 获取元素时的锁工具 */
private final ReentrantLock takeLock = new ReentrantLock();
/** 等待获取元素时的锁对应的等待条件 */
private final Condition notEmpty = takeLock.newCondition();

/** 添加元素时的锁工具 */
private final ReentrantLock putLock = new ReentrantLock();
/** 添加元素锁等待条件 */
private final Condition notFull = putLock.newCondition();

构造方法

public LinkedBlockingQueue() {
    this(Integer.MAX_VALUE);
}

public LinkedBlockingQueue(int capacity) {
    if (capacity <= 0) throw new IllegalArgumentException();
    this.capacity = capacity;
    last = head = new Node<E>(null);
}

public LinkedBlockingQueue(Collection<? extends E> c) {
    this(Integer.MAX_VALUE);
    final ReentrantLock putLock = this.putLock;
    putLock.lock(); // Never contended, but necessary for visibility
    try {
        int n = 0;
        for (E e : c) {
            if (e == null)
                throw new NullPointerException();
            if (n == capacity)
                throw new IllegalStateException("Queue full");
            enqueue(new Node<E>(e));
            ++n;
        }
        count.set(n);
    } finally {
        putLock.unlock();
    }
}

创建LinkedBlockingQueue对象时，可选择指定队列大小，不指定时的队列长度为Integer.MAX_VALUE；
构造方法同时会初始化head节点和tail节点，可知此时这俩节点都只是没有元素的非null的Node节点。
构造方法支持将一个集合数据放入队列中，要求集合里的元素不能为null同时集合的元素个数不能大于Integer.MAX_VALUE，否则会抛出异常。

给队列添加数据

public boolean add(E e)
public boolean offer(E e)
public boolean offer(E e, long timeout, TimeUnit unit) throws InterruptedException
public void put(E e) throws InterruptedException

private void enqueue(Node<E> node) {
    last = last.next = node;
}

LinkedBlockingQueue的add方法添加数据，其实也是访问了AbstractQueue类下的add方法，转到了LinkedBlockingQueue类下的offer方法。
添加数据使用的是putLock，当前队列容量已满时，单纯通过offer方法进行数据添加，直接返回false。但是通过带有超时条件的offer或者put方法进行添加时，会进入到等待的状态。
队列的添加数据，只是把新数据放在队列的尾部。数据添加完毕后要更新当前队列元素的个数。
如果此时队列不满，那么就唤醒其他添加数据但是当时因队列满而给挂起的线程。释放当前线程的putLock锁。

消费队列数据

public E poll()
public E poll(long timeout, TimeUnit unit) throws InterruptedException
public E take() throws InterruptedException 
public E peek()

private E dequeue() {
    Node<E> h = head;
    Node<E> first = h.next;
    h.next = h; // help GC
    head = first;
    E x = first.item;
    first.item = null;
    return x;
}

LinkedBlockingQueue队列被消费数据，使用了takeLock锁。peek方法只是返回当前head节点指向的下一个节点里的元素。不会更换head节点。
poll方法在获取元素时，获取head节点指向的下一个节点里的元素。并更新head节点为这个下一个节点，同时设置head节点里的元素为null。
如果此时队列还有元素，当前线程就会先唤醒之前获取数据但是当时队列没数据就被等待的线程，然后释放tackLock锁

LinkedBlockingQueue小结

LinkedBlockingQueue可以看作是一条传送带（有界），传送带的A点是来放物品，传送带的B点是来取物品。因为每次只能一个来放或取，所以A、B两点分别产生了竞争，相当于有了putLock和takeLock。

当传送带放满的时候就停止转动了，A点所有的工人都停下来了，等待B点的工人取物品。当B点的取不到物品时，所有工人也停下来了，等待A点放物品。

A点的一个工人放好物品后发现当前还能再放，他就喊一个在等待的工人来放物品。同样B点的工人取了物品后发现还有物品，就喊一个等待的工人来取物品。

特殊情况考虑：

当A点没有工人，B点来了工人时，此时因为传送带无物品，B点工人都在等待。这种情况下，A点工人在放了物品后，就给B点发个信号，让B点等待的工人起来干活了。

同样B点没有工人，A点来了工人一直干活导致传送带放满了，A点的工人只能等待，这时B点来了工人取了物品后就给A点发信号，告诉他们传送带有空位，可以干活了。