当前位置： 移动技术网 > IT编程>开发语言>Java > Java并发容器，底层原理深入分析

Java并发容器，底层原理深入分析

2019年05月26日  | 移动技术网IT编程  | 我要评论

concurrenthashmap

 

concurrenthashmap底层具体实现

jdk 1.7底层实现

v2-47fa67448a22910874803a0318c143bb_b.png

将数据分为一段一段的存储，然后给每一段数据配一把锁， 当一个线程占用锁访问其中一个段数据时，其他段的数据也能被其他线程访问。

concurrenthashmap是由segment数组结构和hashentry数组结构组成。 其中segment 实现了 reentrantlock,所以segment是一种可重入锁，扮演锁的角色。 hashentry 用于存储键值对数据。

一个concurrenthashmap里包含一个segment数组。 segment结构和hashmap类似，是一种数组和链表结构， 一个segment包含一个hashentry数组，每个hashentry是一个链表结构的元素， 每个segment守护着一个hashentry数组里的元素，当对hashentry数组的数据进行修改时，必须首先获得对应的segment的锁。

jdk 1.8底层实现

treebin: 红黑二叉树节点 node: 链表节点

 

v2-9e5e57b2227df02dc231978862ff5cf8_b.png

 

concurrenthashmap取消了segment分段锁，采用cas和synchronized来保证并发安全。 数据结构与hashmap1.8的结构类似，数组+链表/红黑二叉树(链表长度>8时，转换为红黑树)。

synchronized只锁定当前链表或红黑二叉树的首节点，这样只要hash值不冲突，就不会产生并发。

 

concurrenthashmap和hashtable的区别

底层数据结构：

  • jdk1.7 的concurrenthashmap底层采用分段的数组+链表实现， jdk1.8 的concurrenthashmap底层采用的数据结构与jdk1.8 的hashmap的结构一样，数组+链表/红黑二叉树。

  • hashtable和jdk1.8 之前的hashmap的底层数据结构类似都是采用数组+链表的形式， 数组是 hashmap 的主体，链表则是主要为了解决哈希冲突而存在的

实现线程安全的方式

  • jdk1.7的concurrenthashmap（分段锁）对整个桶数组进行了分割分段(segment)， 每一把锁只锁容器其中一部分数据，多线程访问容器里不同数据段的数据，就不会存在锁竞争，提高并发访问率。 jdk 1.8 采用数组+链表/红黑二叉树的数据结构来实现，并发控制使用synchronized和cas来操作。

  • hashtable:使用 synchronized 来保证线程安全，效率非常低下。 当一个线程访问同步方法时，其他线程也访问同步方法，可能会进入阻塞或轮询状态， 如使用 put 添加元素，另一个线程不能使用 put 添加元素，也不能使用 get，竞争会越来越激烈。

hashtable全表锁

v2-72e2203eeb5a463c4a0fd6295ce6fc8a_b.png

concurrenthashmap分段锁

 

v2-658c1f06db5fe9820c8c15e151462e7a_b.png

 

 

copyonwritearraylist

public class copyonwritearraylist<e> extends object
implements list<e>, randomaccess, cloneable, serializable
 

在很多应用场景中，读操作可能会远远大于写操作。 由于读操作根本不会修改原有的数据，因此对于每次读取都进行加锁其实是一种资源浪费。 我们应该允许多个线程同时访问list的内部数据，毕竟读取操作是安全的。 这和reentrantreadwritelock读写锁的思想非常类似，也就是读读共享、写写互斥、读写互斥、写读互斥。 jdk中提供了copyonwritearraylist类比相比于在读写锁的思想又更进一步。 为了将读取的性能发挥到极致，copyonwritearraylist 读取是完全不用加锁的，并且写入也不会阻塞读取操作。 只有写入和写入之间需要进行同步等待。这样，读操作的性能就会大幅度提高。

 

copyonwritearraylist的实现机制

copyonwritearraylis 类的所有可变操作（add，set等等）都是通过创建底层数组的新副本来实现的。 当 list 需要被修改的时候，我并不修改原有内容，而是对原有数据进行一次复制，将修改的内容写入副本。 写完之后，再将修改完的副本替换原来的数据，这样就可以保证写操作不会影响读操作了。

copyonwritearraylist是满足copyonwrite的arraylist， 所谓copyonwrite也就是说： 在计算机，如果你想要对一块内存进行修改时，我们不在原有内存块中进行写操作， 而是将内存拷贝一份，在新的内存中进行写操作，写完之后呢，就将指向原来内存指针指向新的内存， 原来的内存就可以被回收掉了。

 

copyonwritearraylist读取和写入源码简单分析

  • copyonwritearraylist读取操作的实现

读取操作没有任何同步控制和锁操作， 因为内部数组array不会发生修改，只会被另外一个array替换，因此可以保证数据安全。

/** the array, accessed only via getarray/setarray. */
private transient volatile object[] array;
public e get(int index) {
    return get(getarray(), index);
}
@suppresswarnings("unchecked")
private e get(object[] a, int index) {
    return (e) a[index];
}
final object[] getarray() {
    return array;
}

 

 

  • copyonwritearraylist读取操作的实现

copyonwritearraylist 写入操作 add() 方法在添加集合的时候加了锁， 保证同步，避免了多线程写的时候会复制出多个副本出来。

/**
 * appends the specified element to the end of this list.
 */
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();//释放锁
    }
}

 

 

 

concurrentlinkedqueue

java提供的线程安全的 queue 可以分为阻塞队列和非阻塞队列，其中阻塞队列的典型例子是 blockingqueue， 非阻塞队列的典型例子是concurrentlinkedqueue，在实际应用中要根据实际需要选用阻塞队列或者非阻塞队列。 阻塞队列可以通过加锁来实现，非阻塞队列可以通过cas操作实现。

concurrentlinkedqueue使用链表作为其数据结构。 concurrentlinkedqueue应该算是在高并发环境中性能最好的队列了。 它之所有能有很好的性能，是因为其内部复杂的实现。

concurrentlinkedqueue 主要使用cas非阻塞算法来实现线程安全。 适合在对性能要求相对较高，对个线程同时对队列进行读写的场景， 即如果对队列加锁的成本较高则适合使用无锁的concurrentlinkedqueue来替代。

 

blockingqueue

java.util.concurrent.blockingqueue 接口有以下阻塞队列的实现：

  • fifo 队列 ：linkedblockingqueue、arrayblockingqueue（固定长度）

  • 优先级队列 ：priorityblockingqueue

提供了阻塞的 take() 和 put() 方法：如果队列为空 take() 将阻塞，直到队列中有内容； 如果队列为满 put() 将阻塞，直到队列有空闲位置。

使用 blockingqueue 实现生产者消费者问题

public class producerconsumer {

    private static blockingqueue<string> queue = new arrayblockingqueue<>(5);

    private static class producer extends thread {
        @override
        public void run() {
            try {
                queue.put("product");
            } catch (interruptedexception e) {
                e.printstacktrace();
            }
            system.out.print("produce..");
        }
    }

    private static class consumer extends thread {

        @override
        public void run() {
            try {
                string product = queue.take();
            } catch (interruptedexception e) {
                e.printstacktrace();
            }
            system.out.print("consume..");
        }
    }
}

 

public static void main(string[] args) {
    for (int i = 0; i < 2; i++) {
        producer producer = new producer();
        producer.start();
    }
    for (int i = 0; i < 5; i++) {
        consumer consumer = new consumer();
        consumer.start();
    }
    for (int i = 0; i < 3; i++) {
        producer producer = new producer();
        producer.start();
    }
}

 

 
produce..produce..consume..consume..produce..consume..produce..consume..produce..consume..

 

 
 

免费java高级资料需要自己领取，涵盖了java、redis、mongodb、mysql、zookeeper、spring cloud、dubbo高并发分布式等教程，一共30g。 传送门：https://mp.weixin.qq.com/s/jzddfh-7ynudmkjt0irl8q

您可能感兴趣的文章:

如对本文有疑问， 点击进行留言回复！！

相关文章:

验证码：
最近更新的文章
大家感兴趣的文章
移动技术网