jdk 原地分析（3）java ConcurrentHashMap结构分析

最新推荐文章于 2023-06-08 06:59:31 发布
最新推荐文章于 2023-06-08 06:59:31 发布
阅读量410 收藏
点赞数
分类专栏： jdk 源代码 文章标签： jdk 源代码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenfenggang/article/details/76563247
版权

1）存储结构：存储结构和hashmap相似，但是添加一个root级别的锁。
链表： 
static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    volatile V val;
    volatile Node<K,V> next;

    Node(int hash, K key, V val, Node<K,V> next) {
        this.hash = hash;
        this.key = key;
        this.val = val;
        this.next = next;
    }
树： 
static final class TreeNode<K,V> extends Node<K,V> {
    TreeNode<K,V> parent;  // red-black tree links
    TreeNode<K,V> left;
    TreeNode<K,V> right;
    TreeNode<K,V> prev;    // needed to unlink next upon deletion
    boolean red;

    TreeNode(int hash, K key, V val, Node<K,V> next,
             TreeNode<K,V> parent) {
        super(hash, key, val, next);
        this.parent = parent;
    }

锁根 
/**
 * TreeNodes used at the heads of bins. TreeBins do not hold user
 * keys or values, but instead point to list of TreeNodes and
 * their root. They also maintain a parasitic read-write lock
 * forcing writers (who hold bin lock) to wait for readers (who do
 * not) to complete before tree restructuring operations.
 */
static final class TreeBin<K,V> extends Node<K,V> {
    TreeNode<K,V> root;
    volatile TreeNode<K,V> first;
    volatile Thread waiter;
    volatile int lockState;
    // values for lockState
    static final int WRITER = 1; // set while holding write lock
    static final int WAITER = 2; // set when waiting for write lock
    static final int READER = 4; // increment value for setting read lock

2）put，里面大量使用unsafe 类，乐观写比同步锁要快很多。concurrent相对于hashmap 就是因为多了 乐观锁的操作 
static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {
    return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
}
static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i,
                                    Node<K,V> c, Node<K,V> v) {
    return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v);
}
因为这些东西，使得线程变的安全，而且乐观锁比悲观锁的性能好好很多。 
   
   
  2.     /** Implementation for put and putIfAbsent */
  3.     final V putVal(K key, V value, boolean onlyIfAbsent) {
  4.         if (key == null || value == null) throw new NullPointerException();
  5.         

  6.         int hash = spread(key.hashCode());
  7.         int binCount = 0;
  8.         for (Node<K,V>[] tab = table;;) {
  9.             Node<K,V> f; int n, i, fh;
  10.             if (tab == null || (n = tab.length) == 0)
  11.                 tab = initTable();
  12.             //分支没有数据，直接写就行。

  13.             else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
  14.                 if (casTabAt(tab, i, null,
  15.                              new Node<K,V>(hash, key, value, null)))
  16.                     break;                   // no lock when adding to empty bin
  17.             }
  18.             //数据多了之后可以在移动，

  19.             else if ((fh = f.hash) == MOVED)
  20.                 tab = helpTransfer(tab, f);
  21.             else {
  22.                 V oldVal = null;
  23.                 synchronized (f) {
  24.                     if (tabAt(tab, i) == f) {
  25.                         if (fh >= 0) {
  26.                             binCount = 1;
  27.                             for (Node<K,V> e = f;; ++binCount) {
  28.                                 K ek;
  29.                                 if (e.hash == hash &&
  30.                                     ((ek = e.key) == key ||
  31.                                      (ek != null && key.equals(ek)))) {
  32.                                     oldVal = e.val;
  33.                                     if (!onlyIfAbsent)
  34.                                         e.val = value;
  35.                                     break;
  36.                                 }
  37.                                 Node<K,V> pred = e;
  38.                                 if ((e = e.next) == null) {
  39.                                     pred.next = new Node<K,V>(hash, key,
  40.                                                               value, null);
  41.                                     break;
  42.                                 }
  43.                             }
  44.                         }
  45.                         else if (f instanceof TreeBin) {
  46.                             Node<K,V> p;
  47.                             binCount = 2;
  48.                             if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
  49.                                                            value)) != null) {
  50.                                 oldVal = p.val;
  51.                                 if (!onlyIfAbsent)
  52.                                     p.val = value;
  53.                             }
  54.                         }
  55.                     }
  56.                 }
  57.                 if (binCount != 0) {
  58.                     if (binCount >= TREEIFY_THRESHOLD)
  59.                         treeifyBin(tab, i);
  60.                     if (oldVal != null)
  61.                         return oldVal;
  62.                     break;
  63.                 }
  64.             }
  65.         }
  66.         addCount(1L, binCount);
  67.         return null;
  68.     }









1）存储结构：存储结构和hashmap相似，但是添加一个root级别的锁。
链表： 
static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    volatile V val;
    volatile Node<K,V> next;

    Node(int hash, K key, V val, Node<K,V> next) {
        this.hash = hash;
        this.key = key;
        this.val = val;
        this.next = next;
    }
树： 
static final class TreeNode<K,V> extends Node<K,V> {
    TreeNode<K,V> parent;  // red-black tree links
    TreeNode<K,V> left;
    TreeNode<K,V> right;
    TreeNode<K,V> prev;    // needed to unlink next upon deletion
    boolean red;

    TreeNode(int hash, K key, V val, Node<K,V> next,
             TreeNode<K,V> parent) {
        super(hash, key, val, next);
        this.parent = parent;
    }

锁根 
/**
 * TreeNodes used at the heads of bins. TreeBins do not hold user
 * keys or values, but instead point to list of TreeNodes and
 * their root. They also maintain a parasitic read-write lock
 * forcing writers (who hold bin lock) to wait for readers (who do
 * not) to complete before tree restructuring operations.
 */
static final class TreeBin<K,V> extends Node<K,V> {
    TreeNode<K,V> root;
    volatile TreeNode<K,V> first;
    volatile Thread waiter;
    volatile int lockState;
    // values for lockState
    static final int WRITER = 1; // set while holding write lock
    static final int WAITER = 2; // set when waiting for write lock
    static final int READER = 4; // increment value for setting read lock

2）put，里面大量使用unsafe 类，乐观写比同步锁要快很多。concurrent相对于hashmap 就是因为多了 乐观锁的操作 
static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {
    return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
}
static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i,
                                    Node<K,V> c, Node<K,V> v) {
    return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v);
}
因为这些东西，使得线程变的安全，而且乐观锁比悲观锁的性能好好很多。 
    
    
  2.     /** Implementation for put and putIfAbsent */
  3.     final V putVal(K key, V value, boolean onlyIfAbsent) {
  4.         if (key == null || value == null) throw new NullPointerException();
  5.         

  6.         int hash = spread(key.hashCode());
  7.         int binCount = 0;
  8.         for (Node<K,V>[] tab = table;;) {
  9.             Node<K,V> f; int n, i, fh;
  10.             if (tab == null || (n = tab.length) == 0)
  11.                 tab = initTable();
  12.             //分支没有数据，直接写就行。

  13.             else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
  14.                 if (casTabAt(tab, i, null,
  15.                              new Node<K,V>(hash, key, value, null)))
  16.                     break;                   // no lock when adding to empty bin
  17.             }
  18.             //数据多了之后可以在移动，

  19.             else if ((fh = f.hash) == MOVED)
  20.                 tab = helpTransfer(tab, f);
  21.             else {
  22.                 V oldVal = null;
  23.                 synchronized (f) {
  24.                     if (tabAt(tab, i) == f) {
  25.                         if (fh >= 0) {
  26.                             binCount = 1;
  27.                             for (Node<K,V> e = f;; ++binCount) {
  28.                                 K ek;
  29.                                 if (e.hash == hash &&
  30.                                     ((ek = e.key) == key ||
  31.                                      (ek != null && key.equals(ek)))) {
  32.                                     oldVal = e.val;
  33.                                     if (!onlyIfAbsent)
  34.                                         e.val = value;
  35.                                     break;
  36.                                 }
  37.                                 Node<K,V> pred = e;
  38.                                 if ((e = e.next) == null) {
  39.                                     pred.next = new Node<K,V>(hash, key,
  40.                                                               value, null);
  41.                                     break;
  42.                                 }
  43.                             }
  44.                         }
  45.                         else if (f instanceof TreeBin) {
  46.                             Node<K,V> p;
  47.                             binCount = 2;
  48.                             if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
  49.                                                            value)) != null) {
  50.                                 oldVal = p.val;
  51.                                 if (!onlyIfAbsent)
  52.                                     p.val = value;
  53.                             }
  54.                         }
  55.                     }
  56.                 }
  57.                 if (binCount != 0) {
  58.                     if (binCount >= TREEIFY_THRESHOLD)
  59.                         treeifyBin(tab, i);
  60.                     if (oldVal != null)
  61.                         return oldVal;
  62.                     break;
  63.                 }
  64.             }
  65.         }
  66.         addCount(1L, binCount);
  67.         return null;
  68.     }







2023Java 并发编程面试题
喜欢猪猪
03-10 549
BlockingQueue 接口是 Queue 的子接口，它的主要用途并不是作为容器，而是作为线程同步的的工具，因此他具有一个很明显的特性，当生产者线程试图向 BlockingQueue 放入元素时，如果队列已满，则线程被阻塞，当消费者线程试图从中取出一个元素时，如果队列为空，则该线程会被阻塞，正是因为它所具有这个特性，所以在程序中多个线程交替向BlockingQueue 中放入元素，取出元素，它可以很好的控制线程之间的通信。因此，当所有的非后台线程结束时，程序也就终止了，同时会杀死进程中的所有后台线程。
java多线程 ConcurrentHashMap源码分析
许诗宇的博客
05-05 273
目录 前言 常量 成员 节点类 构造器 put 插入操作 加锁情况 红黑树的binCount固定为2 返回情况 spread initTable helpTransfer resizeStamp sizeCtl的低16bit 退出循环的条件 treeifyBin tryPresize addCount 计数部分 计数部分结束时 扩容部分 CAS失败影响扩容 fullAddCount wasUncontended的作用 collide的作用 cellsBus
Java8 JDK1.8
最新发布
yake1965
06-08 963
Java 8 的特性
jdk 源码分析（0） java 源码分析汇总
chenfenggang的专栏
08-05 1117
jdk源码分析汇总：后续会不断添加 jdk 源码分析（17）java Semaphore 源码解析及与lock对比 jdk 源码分析（16）java CyclicBarrier 源码解析 jdk 源码分析（15）java CountDownLatch 源码解析 jdk 源码分析（14）java ThreadLocal jdk 源码分析（13）java Ex
JDK 源码复习 concurrent 包 concurrentHashMap 02
郭传志的博客
09-19 165
1. 原理解析 利用 ==CAS + synchronized== 来保证并发更新的安全 底层使用==数组+链表+红黑树==来实现 1.1. 重要成员变量 table：默认为null，初始化发生在第一次插入操作，默认大小为16的数组，用来存储Node节点数据，扩容时大小总是2的幂次方。 nextTable：默认为null，扩容时新生成的数组，其大小为原数组的两倍。 sizeCtl ：默认为0，...
ConcurrentHashMap
java小菜鸡成长之路
12-04 441
ConcurrentHashMap jdk8 ConcurrentHashMap结构 1、Node节点一共有5种类型 1、Node节点，是所有节点的父类，可以单独放入桶内，也可以作为链表的头放入桶内。 2、TreeNode节点，继承自Node，是红黑树的节点，此节点不能直接放入桶内，只能是作为红黑树的节点。 3、TreeBin节点，TreeNode的代理节点，可以放入桶内，这个节点下面可以连接红...
java基础Synchronized原理及逃逸分析
练习时长1个月
02-22 351
Synchronized用法锁升级无锁identity hashcodeagebiased locklock偏向锁轻量级锁重量级锁 用法 synchronized可用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这段代码。 synchronized有三种应用方式： 作用于实例方法，当前实例加锁，进入同步代码前要获得当前实例的锁； 作用于静态方法，当前类加锁，进去同步代码前要获得当前类对象的锁； 作用于代码块，对括号里配置的对象加锁。 锁升级 在说锁升级前时先
JUC集合类 ConcurrentHashMap源码解析 JDK8
anlian523的博客
07-19 2228
ConcurrentHashMap是一种支持并发操作的HashMap，并发控制方面，它使用更小粒度的锁——对每个哈希桶的头节点加锁。虽然这样使得效率更高，能让读写操作最大程序的并发执行，但也造成了读写操作的一致性很弱，比如size()返回的大小可能已经与真实大小不一样，比如clear()调用返回后Map中却拥有着元素。 JDK8的ConcurrentHashMap并不是完美，在阅读源码之前，建议先看看ConcurrentHashMap有些什么bug，以免在这些地方钻牛角尖。
ConcurrentHashMap源码解析 JDK8
聚娃科技开发者博客
01-14 267
一、简介 上篇文章详细介绍了HashMap的源码及原理，本文趁热打铁继续分析ConcurrentHashMap的原理。 首先在看本文之前，希望对HashMap有一个详细的了解。不然看直接看ConcurrentHashMap的源码还是有些费劲的。 相信对HashMap，HashTable有一定了解，应该知道HashMap是不具备线程安全性的，在resize时会丢数据（JDK8），而HashTa...
JDK1.8 ConcurrentHashMap源码解析
掘客DIGGKR
09-08 390
ConcurrentHashMap是conccurrent家族中的一个类，由于它可以高效地支持并发操作，以及被广泛使用，经典的开源框架Spring的底层数据结构就是使用ConcurrentHashMap实现的。与同是线程安全的老大哥HashTable相比，它已经更胜一筹，因此它的锁更加细化，而不是像HashTable一样为几乎每个方法都添加了synchronized锁，这样的锁无疑会影响到性能。 本文的分析的源码是JDK1.8的版本，与JDK1.7的版本有很大的差异。实现线程安全的思想也已经完全变了，它摒弃
【Java X 源码剖析】Map的源码分析--JDK1.8-仍在更新
The Beginning
03-13 286
Map接口下的结构 目录 HashMap（散列表+链表or红黑树） ①public V Put(K key, V value) ②resize() ③public V get(Object key) ④public boolean containsKey(Object Key) ⑤public V remove(Object key) public boolean ...
Java开发者必备：5个高效算法复杂度分析工具，快速提升编程技巧
[Java开发者必备：5个高效算法复杂度分析工具，快速提升编程技巧](https://pablocianes.com/static/2f551b7709aaed60b332d5d57d23abc1/b04cd/notacion-big-o.png) # 1. 算法复杂度基础 在探讨软件性能时，算法...
Java算法优化：从理论到实践的复杂度分析工具应用，打造高效算法
Java算法优化的重要性与目标 ## 1.1 理解算法优化的必要性 Java算法优化是提升软件性能的核心环节之一。随着业务逻辑的复杂化，对效率和资源的合理利用提出了更高的要求。优化算法不仅是解决性能瓶颈的关键，也是...
hbase 源代码解析（23）truncate 和truncate_preserve流程分析
chenfenggang的专栏
10-24 7590
命令作用：清空表数据，但是保留表结构， 分析原因：今天定位一个奇怪的现象，当hbase建立4个region的表，然后用truncate命令时，出现1个region在线而有4个region offline，然后继续put数据，制定split到4个region时，使用truncate_preserve发现出现9个offline，7个failed，并且再put数据时出现表不存在，问题还在定位中。所以需
roaringbitmap 源码解析 bitmap add过程
chenfenggang的专栏
07-06 4499
最近在做标签平台的分析引擎。底层涉及到位图的处理，所以涉及到roaringbitmap。 roaringbitmap 主要使用add and or xor remove serialize deserialize 等操作。 roaringbitmap 主要容器container，以及所有实现，所有操作其实就是这些容器之间的操作。 1、 RoaringBitmap 将整数i
roaringbitmap 源码（4）序列化和反序化以及分布式应用
chenfenggang的专栏
07-08 3335
迭代器和序列化和反序列化serialize：都很简单。 ArrayContainer@Override public void serialize(DataOutput out) throws IOException { out.writeShort(Short.reverseBytes((short) this.cardinality)); // little endian for
jdk 源码分析（10）java unsafe 分析
chenfenggang的专栏
08-03 3230
cas大意就是先去获取一次结果，如果结果和现在不同，就直接返回，因为有其他人修改了；否则会一直尝试去修改。直到成功。
hbase 源代码分析（5）regionLocator 获取region过程 详解
chenfenggang的专栏
07-12 3076
client 首先去zk 里拿到MATA的ServiceName 发送第一次callable.call(),然后 在MATA RS里拿到table的region的ServiceName.然后发送第二次callable。call.获得region信息。
jdk 源码分析（20）java NIO包简单分析
chenfenggang的专栏
08-08 2670
优点，采用多路复用，而且因为采用buffer机制，当读写buffer时不需要阻塞。 nio 也有缺点，因为nio需要很多代码去出去半包问题，而底层采用epoll也是有问题，这些问题在多并发是可能出现，因为这些问题，所以出现netty，netty能快速开发出稳定的通信框架，所以spark/kafka都有netty。
Java内存分析：工具与JDK指令详解
"本文将介绍Java内存分析中常用的工具和指令，包括如何利用这些工具来获取内存使用情况，诊断性能问题，以及理解Java内存结构。" 在Java开发中，理解和分析内存使用是优化应用性能的关键步骤。Java开发人员通常依赖...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值