JDK，常见数据结构解读

时间  2019-12-13
标签 jdk 常见 数据 结构 解读 栏目 Java 繁體版
原文   原文链接

一。情有独钟

　　对数据结构情有独钟，打算慢慢把jdk里的实现都读一遍，发现其中的亮点，持续更新。java

二。ArrayList

　　这应该是咱们学习java最先接触的到的数据结构，众所周知，数组在申请了内存以后，没法扩展；而数组队列，是实现了动态扩容的功能，意义上是为动态数组，实际上的数组扩容是不容许在原地址上伸长的，很简单，由于在你申请的数组空间以后，可能存在别的被申请掉的内存；要实现动态数组，必然是新申请一个更大的连续内存空间，并替换到原来的引用中。数组

 

　　从构造函数，能够清楚看到，elementData，就是这个存储数据的内存地址。数据结构

　　而后，找到添加的接口，add；在真正赋值以前，会进行grow方法。多线程

　　

　　能够看到，真正干活的是这个copyof，找到最后，就是这个方法。并发

　　首先这个泛型数组，会先判断一下若是是Object父类，则直接new Object，若是不是则调用Arrays的接口建立，才去新建一个数组，而后就会去拷贝数组到新的数组，并返回这个被拷贝的数组。ide

    public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
        @SuppressWarnings("unchecked")
        T[] copy = ((Object)newType == (Object)Object[].class)
            ? (T[]) new Object[newLength]
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

　　它的get方法，简单判断一下是否大于元素容量，防止内存泄漏的操做。函数

    public E get(int index) {
        rangeCheck(index);

        return elementData(index);
    }

　　它的remove方法，是将这个位置以后的全部元素，前移一个位置，并将最后的元素设置为null。oop

    public E remove(int index) {
        rangeCheck(index);

        modCount++;
        E oldValue = elementData(index);

        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work

        return oldValue;
    }

　　它提供的排序接口，设计的是传入一个比较器，能够自定升序仍是降序，最终一个分支使用的是mergeSort。最后还校验了一下modcount，先后是否相等，若是不相等抛出并发异常，有点CAS的思想。学习

    @Override
    @SuppressWarnings("unchecked")
    public void sort(Comparator<? super E> c) {
        final int expectedModCount = modCount;
        Arrays.sort((E[]) elementData, 0, size, c);
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
        modCount++;
    }

　　

    public static void sort(Object[] a) {
        if (LegacyMergeSort.userRequested)
            legacyMergeSort(a);
        else
            ComparableTimSort.sort(a, 0, a.length, null, 0, 0);
    }

　　长度小于7插入排序，反正是个n平方的排序，this

    private static void mergeSort(Object[] src,
                                  Object[] dest,
                                  int low,
                                  int high,
                                  int off) {
        int length = high - low;

        // Insertion sort on smallest arrays
        if (length < INSERTIONSORT_THRESHOLD) {
            for (int i=low; i<high; i++)
                for (int j=i; j>low &&
                         ((Comparable) dest[j-1]).compareTo(dest[j])>0; j--)
                    swap(dest, j, j-1);
            return;
        }

        // Recursively sort halves of dest into src
        int destLow  = low;
        int destHigh = high;
        low  += off;
        high += off;
        int mid = (low + high) >>> 1;
        mergeSort(dest, src, low, mid, -off);
        mergeSort(dest, src, mid, high, -off);

        // If list is already sorted, just copy from src to dest.  This is an
        // optimization that results in faster sorts for nearly ordered lists.
        if (((Comparable)src[mid-1]).compareTo(src[mid]) <= 0) {
            System.arraycopy(src, low, dest, destLow, length);
            return;
        }

        // Merge sorted halves (now in src) into dest
        for(int i = destLow, p = low, q = mid; i < destHigh; i++) {
            if (q >= high || p < mid && ((Comparable)src[p]).compareTo(src[q])<=0)
                dest[i] = src[p++];
            else
                dest[i] = src[q++];
        }
    }

 

三。PriorityQueue

　　优先队列，读做优先写做二叉树，也叫堆（大顶堆，小顶堆）。

　　它的实现方法是数组，使用数组作二叉树，每一个元素e[i]的孩子为e[2*i+1]，e[2*i+2]。

　　找到添加元素的方法；比较器为空的时候；它从末尾插入，先找出父亲，若是父节点比本身大，则继续往上，将父节点往下移动，直到找到比它小的位置插入，默认是一个小顶堆。

 

    public boolean offer(E e) {
        if (e == null)
            throw new NullPointerException();
        modCount++;
        int i = size;
        if (i >= queue.length)
            grow(i + 1);
        size = i + 1;
        if (i == 0)
            queue[0] = e;
        else
            siftUp(i, e);
        return true;
    }

    private void siftUpComparable(int k, E x) {
        Comparable<? super E> key = (Comparable<? super E>) x;
        while (k > 0) {
            int parent = (k - 1) >>> 1;
            Object e = queue[parent];
            if (key.compareTo((E) e) >= 0)
                break;
            queue[k] = e;
            k = parent;
        }
        queue[k] = key;
    }

　　弹出操做就是把堆定元素拿走，而后从末尾拿出一个元素，放在堆顶，不断地下沉。

 

    public E poll() {
        if (size == 0)
            return null;
        int s = --size;
        modCount++;
        E result = (E) queue[0];
        E x = (E) queue[s];
        queue[s] = null;
        if (s != 0)
            siftDown(0, x);
        return result;
    }
    private void siftDownComparable(int k, E x) {
        Comparable<? super E> key = (Comparable<? super E>)x;
        int half = size >>> 1;        // loop while a non-leaf
        while (k < half) {
            int child = (k << 1) + 1; // assume left child is least
            Object c = queue[child];
            int right = child + 1;
            if (right < size &&
                ((Comparable<? super E>) c).compareTo((E) queue[right]) > 0)
                c = queue[child = right];
            if (key.compareTo((E) c) <= 0)
                break;
            queue[k] = c;
            k = child;
        }
        queue[k] = key;
    }

 

四。ArrayBlockingQueue

　　看腻了数组队列，咱们来看多线程的阻塞队列是怎么实现的；

　　粗浅的看，它是在多线程中保持一致性的一种数据结构，保持一致性只有两种思路：（1）假设它发生了冲突，则必然加锁（悲观）（2）假设他不必定产生冲突，CAS无锁实现（乐观）；

　　固然，它最基本的数据都是数组；

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

　　从以上的代码，很是直白，首先只能有一个线程进入这个数据操做的代码，而且队列是不扩容的，一旦达到最大容量，则直接拒绝，返回false；

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

　　正如咱们认知的同样，它是一个先进先出的队列，因此在下标达到最大长度以后，会reset成0，而且入队以后，还会唤醒一个事件，就是非空；

　　咱们还有一个put方法能够入队；

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

　　这个队列至关于不是快速失败，而是将当前线程park，使用一个condition的await，让线程等待；

　　它的获取方法take，咱们来阅读如下；

    public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            while (count == 0)
                notEmpty.await();
            return dequeue();
        } finally {
            lock.unlock();
        }
    }

　　使用的是一个线程中断锁，而且在队列为空的时候，park当前线程；与入队方法enqueue成对应，有元素进来的时候会signal阻塞在此的线程；

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

　　这个操做，在结束的时候会唤醒阻塞在put的线程，告诉他有位置能够进来了。

　　而此外，它还提供了带等待时间的阻塞方法。

public boolean offer(E e, long timeout, TimeUnit unit)
public E poll(long timeout, TimeUnit unit)

　　而后它的size，也是须要获取重入锁的，不是非阻塞的。

　　这么看，它有点像--消息队列。

 

五。ConcurrentLinkedQueue

　　并发无锁链表队列，由于线程不会被park，因此效率较高，可是可能引发cpu运算太高。它是在普通链表的基础上，添加了并发的控制， 并采用CAS原子操做保证内存的有序写入。

　　它的基本元素，Node，只有两个属性，原子的item和next。

java.util.concurrent.ConcurrentLinkedQueue.Node
Node<E>
        volatile E item;
        volatile Node<E> next;

　　初始化的时候，head和tail都指向new出来的一个Node上。

head = tail = new Node<E>(null);

　　咱们只须要关心它的添加（offer）和获取（poll）接口是什么样的流程就能够了。

　　offer接口

    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) {// 若是是队尾 则尝试CAS插入
                if (p.casNext(null, newNode)) {
                    // 若是tail节点在插入前不是指向末尾节点，则更新tail
                    // 延迟更新也没事，始终会有一个线程更新成功
                    if (p != t) 
                        casTail(t, newNode);  // Failure is OK.
                    return true;
                }
                // Lost CAS race to another thread; re-read next
            }
            else if (p == q)
                // 因为poll方法，会将节点自引用以便gc，因此要从头节点开始找
                p = (t != (t = tail)) ? t : head;
            else
                // 若是t的引用地址和tail的一致，则p往下找（p=p.next的意思）
                // 若是不一致，则直接拿到tail并赋值给p
                p = (p != t && t != (t = tail)) ? t : q;
        }
    }

　　在单线程插入的时候，插入完成以后如上图。若是继续插入，则p和t不相等，会更新tail的值，这就是快照时候tail不是指向最后一个节点才会执行的逻辑。

　　若是是多线程插入，在上一个线程没有更新tail的时候，它可能会一直p=p.next的流程，这时候另外一个线程更新了tail的地址，这时候须要刷新t的位置。

　　offer和offer方法的多线程冲突，主要在于tail指针的位置问题。

　　接下来咱们看看poll方法。

    public E poll() {
        restartFromHead:
        for (;;) {
            for (Node<E> h = head, p = h, q;;) {
                E item = p.item;
                // 出队是更新节点data为null
                if (item != null && p.casItem(item, null)) {
                         // 若是p节点的下一个不为空则head指向下一个，不然指向p
                        updateHead(h, ((q = p.next) != null) ? q : p);
                    return item;
                }
                else if ((q = p.next) == null) {// 若是下一个是null 则更新头节点为自引用
                    updateHead(h, p);
                    return null;
                }
                else if (p == q)// 撞到了自引用 则跳出循环从新copy快照
                    continue restartFromHead;
                else
                    p = q;// p = p.next的意思
            }
        }
    }

 

　　咱们假设队列的状况是。h仍是指向head原地址，p通过一步以后会指向h的next。这时候要将p的Node的item更新为null，并设置head指针，并且p.next不为空，则head会更新到p.next上。

　　更新以后的状态是。

　　若是这个时候tail没有更新，仍是指向最初的那个节点，也就是offer与poll的冲突。这时候offer就会走第二个else if条件，拿到head。

 

　　只有三四行代码，却那么多场景，真是大师做品。写得这么难懂，是由于能够节省CAS指令，咱们本身写的CAS操做是util success，这样可能会执行不少条，它这里的head和tail更新不强制必定成功。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程