欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

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

程序员文章站 2022-07-10 23:42:12
ConcurrentHashMap ConcurrentHashMap底层具体实现 JDK 1.7底层实现 将数据分为一段一段的存储,然后给每一段数据配一把锁, 当一个线程占用锁访问其中一个段数据时,其他段的数据也能被其他线程访问。 ConcurrentHashMap是由Segment数组结构和Ha ......

concurrenthashmap

 

concurrenthashmap底层具体实现

jdk 1.7底层实现

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

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

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

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

jdk 1.8底层实现

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

 

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

 

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全表锁

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

concurrenthashmap分段锁

 

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

 

 

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