Java基础（十三）

最新推荐文章于 2021-10-22 15:53:05 发布

Lucky Curve。

最新推荐文章于 2021-10-22 15:53:05 发布

阅读量198

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/LuckyCurve/article/details/104931403

版权

Java 专栏收录该内容

14 篇文章 1 订阅

订阅专栏

框架是个好东西，可早晚有一天会过时，这世界上就没有亘古不变的东西，来学下Java基础吧

JDK提供的并发容器

ConcurrentHashMap：线程安全的HashMap
CopyOnWriteArrayList：线程安全的List，读多写少的场合性能非常好，取代了Vector
ConcurrentLinkedQueue：高效的并发队列，可以看做一个并发的LinkedList，是一个非阻塞队列
BlockingQueue：阻塞队列的接口，JDK内部实现了，非常适合用于数据共享的通道
ConcurrentSkipListMap：跳表的实现，是一个Map，可以进行快速的查找

ConcurrentHashMap

HashMap是线程不安全的，如果我们要保证线程安全，可以使用Collections.synchronizedMap()方法来实现对Map的包装，相当于对HashMap加了一个全局锁，非常影响性能【HashTable的做法】，而随之而来的ConcurrentHashMap无论是在读操作和写操作都大大的提高了性能，在读操作中基本不会出现加锁的情况，而写操作也是通过分段锁的技术来保证了很高的性能

至于ConcurrentHashMap和HashTable以及他的底层实现原理，在前面已经说过【Java基础（九）】

CopyOnWriteArrayList

1.简介：

应该有这样的思想：读操作不会改变原有的数据，所以每次对读取操作进行加锁其实是一种浪费。要有ReentrantReadWriteLock读写锁的：读读共享，写写互斥，读写互斥的思想。而JDK提供的CopyOnWriteArrayList就是最好的实现，将性能发挥到了极致，在读取的时候是完全不会进行加锁的，写入的时候也不会进行阻塞读取的操作，只有写入和写入之间会阻塞，所以CopyOnWriteArrayList的读取性能远远优越于写入性能

2.实现原理：

对CopyOnWriteArrayList数据修改的操作并不会直接修改原有内容，而是将原有内容复制出来，修改复制的内容，修改完成后再将原有内容进行覆盖（⚠️并不是真正的覆盖），和线程操作主内存的思路一样，这样就爆炸了写操作不会影响读操作了。

CopyOnWriteArrayList是满足CopyWrite的ArrayList，而CopyWrite指的就是在计算机中，如果想要对内存进行修改，不会直接修改原有内存，而是复制原有内存的数据，在新内存中进行写入操作，完成之后指针就从原有内存指向了新内存，原来的内存即被回收掉了

3.源码分析

    final transient Object lock = new Object();
    private transient volatile Object[] array;

    final Object[] getArray() {
        return this.array;
    }

    final void setArray(Object[] a) {
        this.array = a;
    }

读取都没有加锁，原因是读写不会在同一块内存中出现，所以不会出现信息不对称的情况

    public boolean add(E e) {
        synchronized(this.lock) {
            Object[] es = this.getArray();
            int len = es.length;
            es = Arrays.copyOf(es, len + 1);
            es[len] = e;
            this.setArray(es);
            return true;
        }
    }

写入操作加了锁，是为了防止多个线程同时Copy多个副本出来，造成信息不对称

ConcurrentLinkedQueue

Java提供的线程安全的队列可以分为阻塞的和非阻塞的，阻塞队列的代表就是BlockingQueue，非阻塞的代表例子就是ConcurrentLinkedQueue，两者并无明显的优劣，选用时要根据实际情况而定，阻塞队列可以通过加锁来实现，非阻塞队列可以通过CAS（乐观锁）操作来实现

ConcurrentLinkedQueue底层使用链表来作为底层的数据结构，ConcurrentLinkedQueue应该是高并发环境下性能表现最好的Queue的，原因在于他内部的复杂实现

2.实现原理：

比较复杂，不好分析，只要知道是通过CAS来实现非阻塞的就行了

3.适用场景：

对性能要求较高，同时队列的读写存在于多个线程同时进行的情况

BlockingQueue【接口】

1.简单介绍：

阻塞队列被广泛用于“生产者–消费者”的问题中，当队列已经满了，生产者线程会被阻塞，直到队列不满为止。当队列为空时，消费者线程会被阻塞，直到队列非空

2.继承结构：

Collection<–Queue<–BlockingQueue

主要实现类为：ArrayBlockingQueue，LinkedBlockingQueue和priorityBlockingQueue

3.实现类简介：

1）ArrayBlockingQueue：底层采用数组，定长，采用可重入锁来控制，默认是非公平锁，也可以指定为公平锁，代码如下：

    public ArrayBlockingQueue(int capacity) {
        this(capacity, false);
    }

    public ArrayBlockingQueue(int capacity, boolean fair) {
        if (capacity <= 0) {
            throw new IllegalArgumentException();
        } else {
            this.items = new Object[capacity];
            this.lock = new ReentrantLock(fair);
            this.notEmpty = this.lock.newCondition();
            this.notFull = this.lock.newCondition();
        }
    }

2）LinkedBlockingQueue：底层采用单向链表，可以做无界队列也可以当有界队列来使用，与ArrayBlockingQueue相比有更高的吞吐量，为了防止容量激增，内存损耗严重，可以在创建时候就指定max，如果不指定则队列最长可达到2147483647【接近于无界】，构造方法如下：

    public LinkedBlockingQueue() {
        this(2147483647);
    }

    public LinkedBlockingQueue(int capacity) {
        this.count = new AtomicInteger();
        this.takeLock = new ReentrantLock();
        this.notEmpty = this.takeLock.newCondition();
        this.putLock = new ReentrantLock();
        this.notFull = this.putLock.newCondition();
        if (capacity <= 0) {
            throw new IllegalArgumentException();
        } else {
            this.capacity = capacity;
            this.last = this.head = new LinkedBlockingQueue.Node((Object)null);
        }
    }

3）PriorityBlockingQueue：是一个支持优先级的无界阻塞队列，默认使用自然规则排序，也可以通过自定义类实现compareTo方法来实现元素之间的比较排序，或者初始化时候指定Comparator来指定排序规则

PriorityBlockingQueue是通过重入锁来控制并发的，队列为无界队列，创建对象传入的int值是队列初始化长度，如果空间不够就会自动扩充，构造方法摘要如下：

	public PriorityBlockingQueue() 
    public PriorityBlockingQueue(int initialCapacity)
    public PriorityBlockingQueue(int initialCapacity, Comparator<? super E> comparator)
    public PriorityBlockingQueue(Collection<? extends E> c)