高并发容器set&Queue篇

 

一、Set

Set是数学的集合，无序的，不重复

下表Set各个实现的对比

HashSet	基于hashMap	线程非安全
CopyOnwriteArraySet	基于CopyOnwriteArrayList	线程安全
concurrentskipListSet	基于currentskipListMap	线程安全、查询快，且有序

 

直接看源码

    public HashSet() {
        map = new HashMap<>();
    }

我们可以看到HashSet初始化就是初始化一个HashMap

接下我们看下add方法

    public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }

遍历的方法

    public Iterator<E> iterator() {
        return map.keySet().iterator();
    }

可以看出来add方法就是放入一个空的对象 取值时候就是获取key的值来保证set无重复数据的特性

二、Queue

1、Queue Api

add remove element 三个方法“脾气暴躁” 动不动抛异常

offer poll peek相对柔和

阻塞和非阻塞的区别

当queue 放入元素时阻塞方法会一直等待一直等到有空余位置时候才结束阻塞，非阻塞方法就是线程直接忽略 容易丢失数据

同理当queue取出元素时候方法会一直等待直到有数据进来才会结束阻塞

接下来介绍下具体的队列解释下

ArrayBlockingQueue

顾名思义 实现的原理是数组接下来我们看下源码

​      /** The queued items */
    final Object[] items;

    /** items index for next take, poll, peek or remove */
    int takeIndex;

    /** items index for next put, offer, or add */
    int putIndex;

  public void put(E e) throws InterruptedException {
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            while (count == items.length)
//阻塞队列
                notFull.await();
            enqueue(e);
        } finally {
            lock.unlock();
        }
    }
public boolean offer(E e) {
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            if (count == items.length)
                return false;
            else {
                enqueue(e);
                return true;
            }
        } finally {
            lock.unlock();
        }
    }
   private void enqueue(E x) {
        // assert lock.getHoldCount() == 1;
        // assert items[putIndex] == null;
        final Object[] items = this.items;
//添加元素
        items[putIndex] = x;

        if (++putIndex == items.length)
            putIndex = 0;
        count++;
//唤醒
        notEmpty.signal();
    }

​

看代码可以看出来offer和put的区别在于长度满的时候offer直接返回false put是阻塞

    public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            while (count == 0)
                notEmpty.await();
            return dequeue();
        } finally {
            lock.unlock();
        }
    }
    public E poll() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return (count == 0) ? null : dequeue();
        } finally {
            lock.unlock();
        }
    }
    private E dequeue() {
        // assert lock.getHoldCount() == 1;
        // assert items[takeIndex] != null;
        final Object[] items = this.items;
        @SuppressWarnings("unchecked")
        E x = (E) items[takeIndex];
        items[takeIndex] = null;
        if (++takeIndex == items.length)
            takeIndex = 0;
        count--;
        if (itrs != null)
            itrs.elementDequeued();
        notFull.signal();
        return x;
    }

take和poll也是一样的原理

LinkedBlockingQueue 

LinkedBlockingQueue 是根据LinkedBlocking实现的

看下源码

    public void put(E e) throws InterruptedException {
        if (e == null) throw new NullPointerException();
        // Note: convention in all put/take/etc is to preset local var
        // holding count negative to indicate failure unless set.
        int c = -1;
        Node<E> node = new Node<E>(e);
        final ReentrantLock putLock = this.putLock;
        final AtomicInteger count = this.count;
        putLock.lockInterruptibly();
        try {
            /*
             * Note that count is used in wait guard even though it is
             * not protected by lock. This works because count can
             * only decrease at this point (all other puts are shut
             * out by lock), and we (or some other waiting put) are
             * signalled if it ever changes from capacity. Similarly
             * for all other uses of count in other wait guards.
             */
            while (count.get() == capacity) {
                notFull.await();
            }
            enqueue(node);
            c = count.getAndIncrement();
            if (c + 1 < capacity)
                notFull.signal();
        } finally {
            putLock.unlock();
        }
        if (c == 0)
            signalNotEmpty();
    }
    public boolean offer(E e) {
        if (e == null) throw new NullPointerException();
        final AtomicInteger count = this.count;
        if (count.get() == capacity)
            return false;
        int c = -1;
        Node<E> node = new Node<E>(e);
        final ReentrantLock putLock = this.putLock;
        putLock.lock();
        try {
            if (count.get() < capacity) {
                enqueue(node);
                c = count.getAndIncrement();
                if (c + 1 < capacity)
                    notFull.signal();
            }
        } finally {
            putLock.unlock();
        }
        if (c == 0)
            signalNotEmpty();
        return c >= 0;
    }

阻塞和非阻塞也是一样的实现

ArrayBlockingQueue和LinkedBlockingQueue 都是阻塞队列线程安全 但是效率有点低 

ConcurrentLinkedingQueue

源码里面是没有阻塞方法的

 public boolean offer(E e) {
        checkNotNull(e);
        final Node<E> newNode = new Node<E>(e);

        for (Node<E> t = tail, p = t;;) {
            Node<E> q = p.next;
            if (q == null) {
                // p is last node
                if (p.casNext(null, newNode)) {
                    // Successful CAS is the linearization point
                    // for e to become an element of this queue,
                    // and for newNode to become "live".
                    if (p != t) // hop two nodes at a time
                        casTail(t, newNode);  // Failure is OK.
                    return true;
                }
                // Lost CAS race to another thread; re-read next
            }
            else if (p == q)
                // We have fallen off list.  If tail is unchanged, it
                // will also be off-list, in which case we need to
                // jump to head, from which all live nodes are always
                // reachable.  Else the new tail is a better bet.
                p = (t != (t = tail)) ? t : head;
            else
                // Check for tail updates after two hops.
                p = (p != t && t != (t = tail)) ? t : q;
        }
    }

    public E poll() {
        restartFromHead:
        for (;;) {
            for (Node<E> h = head, p = h, q;;) {
                E item = p.item;

                if (item != null && p.casItem(item, null)) {
                    // Successful CAS is the linearization point
                    // for item to be removed from this queue.
                    if (p != h) // hop two nodes at a time
                        updateHead(h, ((q = p.next) != null) ? q : p);
                    return item;
                }
                else if ((q = p.next) == null) {
                    updateHead(h, p);
                    return null;
                }
                else if (p == q)
                    continue restartFromHead;
                else
                    p = q;
            }
        }
    }

源码里面使用了CAS保证安全实现了无锁编程