【死磕 Java 并发】—– J.U.C 之 ConcurrentHashMap 红黑树转换分析

如何用libwebsocket库在stm32F407上实现websocket客户端? 🏆本文收录于 《全栈 Bug 调优(实战版)》 专栏。专栏聚焦真实项目中的各类疑难 Bug,从成因剖析 → 排查路径 → 解决方案 → 预防优化全链路拆解,形成一套可复用、可沉淀的实战知识体系。无论你是初入职场的开发者,还是负责复杂项目的资深工程师,都可以在这里构建一套属于自己的「问题诊断与性能调优」方法论,助你稳步进阶、放大技术价值 。 阅读详情

点击上方“芋道源码”,选择“置顶公众号”

技术文章第一时间送达!

源码精品专栏

 

来源:http://cmsblogs.com/?p=2329

红黑树旋转红黑树插入节点ConcurrentHashMap 的treeifyBin过程


在【死磕Java并发】—–J.U.C之Java并发容器:ConcurrentHashMap一文中详细阐述了ConcurrentHashMap的实现过程,其中有提到在put操作时,如果发现链表结构中的元素超过了TREEIFY_THRESHOLD(默认为8),则会把链表转换为红黑树,已便于提高查询效率。代码如下:

if (binCount >= TREEIFY_THRESHOLD)
    treeifyBin(tab, i);

下面博主将详细分析整个过程,并用一个链表转换为红黑树的过程为案例来分析。博文从如下几个方法进行分析阐述:

  1. 红黑树

  2. ConcurrentHashMap链表转红黑树源码分析

  3. 链表转红黑树案例

红黑树

先看红黑树的基本概念:红黑树是一课特殊的平衡二叉树,主要用它存储有序的数据,提供高效的数据检索,时间复杂度为O(lgn)。红黑树每个节点都有一个标识位表示颜色,红色或黑色,具备五种特性:

  1. 每个节点非红即黑

  2. 根节点为黑色

  3. 每个叶子节点为黑色。叶子节点为NIL节点,即空节点

  4. 如果一个节点为红色,那么它的子节点一定是黑色

  5. 从一个节点到该节点的子孙节点的所有路径包含相同个数的黑色节点

请牢记这五个特性,它在维护红黑树时选的格外重要

红黑树结构图如下:

[<img src="http://cmsblogs.qiniudn.com/wp-content/uploads/2017/06/201705040001_24_thumb.png" alt="201705040001_24]" />

对于红黑树而言,它主要包括三个步骤:左旋、右旋、着色。所有不符合上面五个特性的“红黑树”都可以通过这三个步骤调整为正规的红黑树。

旋转

当对红黑树进行插入和删除操作时可能会破坏红黑树的特性。为了继续保持红黑树的性质,则需要通过对红黑树进行旋转和重新着色处理,其中旋转包括左旋、右旋。

左旋
左旋示意图如下:
[<img src="http://cmsblogs.qiniudn.com/wp-content/uploads/2017/06/2017050400024_thumb.gif" alt="2017050400024]" />
左旋处理过程比较简单,将E的右孩子S调整为E的父节点、S节点的左孩子作为调整后E节点的右孩子。

右旋
[<img src="http://cmsblogs.qiniudn.com/wp-content/uploads/2017/06/2017050400034_thumb.gif" alt="2017050400034]" />

红黑树插入节点

由于链表转换为红黑树只有添加操作,加上篇幅有限所以这里就只介绍红黑树的插入操作,关于红黑树的详细情况,烦请各位Google。

在分析过程中,我们已下面一颗简单的树为案例,根节点G、有两个子节点P、U,我们新增的节点为N

[<img src="http://cmsblogs.qiniudn.com/wp-content/uploads/2017/06/2017050400044_thumb.png" alt="2017050400044]" />

红黑树默认插入的节点为红色,因为如果为黑色,则一定会破坏红黑树的规则5(从一个节点到该节点的子孙节点的所有路径包含相同个数的黑色节点)。尽管默认的节点为红色,插入之后也会导致红黑树失衡。红黑树插入操作导致其失衡的主要原因在于插入的当前节点与其父节点的颜色冲突导致(红红,违背规则4:如果一个节点为红色,那么它的子节点一定是黑色)。
[<img src="http://cmsblogs.qiniudn.com/wp-content/uploads/2017/06/2017050400054_thumb.png" alt="2017050400054]" />
要解决这类冲突就靠上面三个操作:左旋、右旋、重新着色。由于是红红冲突,那么其祖父节点一定存在且为黑色,但是叔父节点U颜色不确定,根据叔父节点的颜色则可以做相应的调整。

1 叔父U节点是红色

如果叔父节点为红色,那么处理过程则变得比较简单了:更换G与P、U节点的颜色,下图(一)。
[<img src="http://cmsblogs.qiniudn.com/wp-content/uploads/2017/06/201705040006_24_thumb.png" alt="201705040006_24]" />

当然这样变色可能会导致另外一个问题了,就是父节点G与其父节点GG颜色冲突(上图二),那么这里需要将G节点当做新增节点进行递归处理。

2 叔父U节点为黑叔

如果当前节点的叔父节点U为黑色,则需要根据当前节点N与其父节点P的位置决定,分为四种情况:

  1. N是P的右子节点、P是G的右子节点

  2. N是P的左子节点,P是G的左子节点

  3. N是P的左子节点,P是G的右子节点

  4. N是P的右子节点,P是G的左子节点

情况1、2称之为外侧插入、情况3、4是内侧插入,之所以这样区分是因为他们的处理方式是相对的。

2.1 外侧插入

以N是P的右子节点、P是G的右子节点为例,这种情况的处理方式为:以P为支点进行左旋,然后交换P和G的颜色(P设置为黑色,G设置为红色),如下:
[<img src="http://cmsblogs.qiniudn.com/wp-content/uploads/2017/06/201705040007_24_thumb.png" alt="201705040007_24]" />

左外侧的情况(N是P的左子节点,P是G的左子节点)和上面的处理方式一样,先右旋,然后重新着色。

2.2 内侧插入

以N是P的左子节点,P是G的右子节点情况为例。内侧插入的情况稍微复杂些,经过一次旋转、着色是无法调整为红黑树的,处理方法如下:先进行一次右旋,再进行一次左旋,然后重新着色,即可完成调整。注意这里两次右旋都是以新增节点N为支点不是P。这里将N节点的两个NIL节点命名为X、L。如下:

[<img src="http://cmsblogs.qiniudn.com/wp-content/uploads/2017/06/2017050400084_thumb.png" alt="2017050400084]" />

至于左内侧则处理逻辑如下:先进行右旋,然后左旋,最后着色。

ConcurrentHashMap 的treeifyBin过程

ConcurrentHashMap的链表转换为红黑树过程就是一个红黑树增加节点的过程。在put过程中,如果发现链表结构中的元素超过了TREEIFY_THRESHOLD(默认为8),则会把链表转换为红黑树:

if (binCount >= TREEIFY_THRESHOLD)
    treeifyBin(tab, i);

treeifyBin主要的功能就是把链表所有的节点Node转换为TreeNode节点,如下:

    private final void treeifyBin(Node<K,V>[] tab, int index) {
        Node<K,V> b; int n, sc;
        if (tab != null) {
            if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
                tryPresize(n << 1);
            else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
                synchronized (b) {
                    if (tabAt(tab, index) == b) {
                        TreeNode<K,V> hd = null, tl = null;
                        for (Node<K,V> e = b; e != null; e = e.next) {
                            TreeNode<K,V> p =
                                new TreeNode<K,V>(e.hash, e.key, e.val,
                                                  null, null);
                            if ((p.prev = tl) == null)
                                hd = p;
                            else
                                tl.next = p;
                            tl = p;
                        }
                        setTabAt(tab, index, new TreeBin<K,V>(hd));
                    }
                }
            }
        }
    }

先判断当前Node的数组长度是否小于MIN_TREEIFY_CAPACITY(64),如果小于则调用tryPresize扩容处理以缓解单个链表元素过大的性能问题。否则则将Node节点的链表转换为TreeNode的节点链表,构建完成之后调用setTabAt()构建红黑树。TreeNode继承Node,如下:

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

我们以下面一个链表作为案例,结合源代码来分析ConcurrentHashMap创建红黑树的过程:

201705040009_2

12

12作为跟节点,直接为将红编程黑即可,对应源码:

                next = (TreeNode<K,V>)x.next;
                x.left = x.right = null;
                if (r == null) {
                    x.parent = null;
                    x.red = false;
                    r = x;
                }
201705040010


(【注】:为了方便起见,这里省略NIL节点,后面也一样)

1

此时根节点root不为空,则插入节点时需要找到合适的插入位置,源码如下:

                    K k = x.key;
                    int h = x.hash;
                    Class<?> kc = null;
                    for (TreeNode<K,V> p = r;;) {
                        int dir, ph;
                        K pk = p.key;
                        if ((ph = p.hash) > h)
                            dir = -1;
                        else if (ph < h)
                            dir = 1;
                        else if ((kc == null &&
                                  (kc = comparableClassFor(k)) == null) ||
                                 (dir = compareComparables(kc, k, pk)) == 0)
                            dir = tieBreakOrder(k, pk);
                            TreeNode<K,V> xp = p;
                        if ((p = (dir <= 0) ? p.left : p.right) == null) {
                            x.parent = xp;
                            if (dir <= 0)
                                xp.left = x;
                            else
                                xp.right = x;
                            r = balanceInsertion(r, x);
                            break;
                        }
                    }

从上面可以看到起处理逻辑如下:

  1. 计算节点的hash值 p。dir 表示为往左移还是往右移。x 表示要插入的节点,p 表示带比较的节点。

  2. 从根节点出发,计算比较节点p的的hash值 ph ,若ph > h ,则dir = -1 ,表示左移,取p = p.left。若p == null则插入,若 p != null,则继续比较,直到直到一个合适的位置,最后调用balanceInsertion()方法调整红黑树结构。ph < h,右移。

  3. 如果ph = h,则表示节点“冲突”(和HashMap冲突一致),那怎么处理呢?首先调用comparableClassFor()方法判断节点的key是否实现了Comparable接口,如果kc != null ,则通过compareComparables()方法通过compareTo()比较带下,如果还是返回 0,即dir == 0,则调用tieBreakOrder()方法来比较了。tieBreakOrder如下:

           static int tieBreakOrder(Object a, Object b) {
               int d;
               if (a == null || b == null ||
                   (d = a.getClass().getName().
                    compareTo(b.getClass().getName())) == 0)
                   d = (System.identityHashCode(a) <= System.identityHashCode(b) ?
                        -1 : 1);
               return d;
           }

tieBreakOrder()方法最终还是通过调用System.identityHashCode()方法来比较。

确定插入位置后,插入,由于插入的节点有可能会打破红黑树的结构,所以插入后调用balanceInsertion()方法来调整红黑树结构。

    static <K,V> TreeNode<K,V> balanceInsertion(TreeNode<K,V> root,
                                                TreeNode<K,V> x) {
        x.red = true;       // 所有节点默认插入为红
        for (TreeNode<K,V> xp, xpp, xppl, xppr;;) {

            // x.parent == null,为跟节点,置黑即可
            if ((xp = x.parent) == null) {
                x.red = false;
                return x;
            }
            // x 父节点为黑色,或者x 的祖父节点为空,直接插入返回
            else if (!xp.red || (xpp = xp.parent) == null)
                return root;

            /*
             * x 的 父节点为红色
             * ---------------------
             * x 的 父节点 为 其祖父节点的左子节点
             */
            if (xp == (xppl = xpp.left)) {
                /*
                 * x的叔父节点存在,且为红色,颜色交换即可
                 * x的父节点、叔父节点变为黑色,祖父节点变为红色
                 */
                if ((xppr = xpp.right) != null && xppr.red) {
                    xppr.red = false;
                    xp.red = false;
                    xpp.red = true;
                    x = xpp;
                }
                else {
                    /*
                     * x 为 其父节点的右子节点,则为内侧插入
                     * 则先左旋,然后右旋
                     */
                    if (x == xp.right) {
                        // 左旋
                        root = rotateLeft(root, x = xp);
                        // 左旋之后x则会变成xp的父节点
                        xpp = (xp = x.parent) == null ? null : xp.parent;
                    }

                    /**
                     * 这里有两部分。
                     * 第一部分:x 原本就是其父节点的左子节点,则为外侧插入,右旋即可
                     * 第二部分:内侧插入后,先进行左旋,然后右旋
                     */
                    if (xp != null) {
                        xp.red = false;
                        if (xpp != null) {
                            xpp.red = true;
                            root = rotateRight(root, xpp);
                        }
                    }
                }
            }

            /**
             * 与上相对应
             */
            else {
                if (xppl != null && xppl.red) {
                    xppl.red = false;
                    xp.red = false;
                    xpp.red = true;
                    x = xpp;
                }
                else {
                    if (x == xp.left) {
                        root = rotateRight(root, x = xp);
                        xpp = (xp = x.parent) == null ? null : xp.parent;
                    }
                    if (xp != null) {
                        xp.red = false;
                        if (xpp != null) {
                            xpp.red = true;
                            root = rotateLeft(root, xpp);
                        }
                    }
                }
            }
        }
    }

回到节点1,其父节点为黑色,即:

            else if (!xp.red || (xpp = xp.parent) == null)
                return root;

直接插入:

201705040011_3

9

9作为1的右子节点插入,但是存在红红冲突,此时9的并没有叔父节点。9的父节点1为12的左子节点,9为其父节点1的右子节点,所以处理逻辑是先左旋,然后右旋,对应代码如下:

                        if (x == xp.right) {
                            root = rotateLeft(root, x = xp);
                            xpp = (xp = x.parent) == null ? null : xp.parent;
                        }
                        if (xp != null) {
                            xp.red = false;
                            if (xpp != null) {
                                xpp.red = true;
                                root = rotateRight(root, xpp);
                            }
                        }

图例变化如下:

201705040012

2

节点2 作为1 的右子节点插入,红红冲突,切其叔父节点为红色,直接变色即可,:

                    if ((xppr = xpp.right) != null && xppr.red) {
                        xppr.red = false;
                        xp.red = false;
                        xpp.red = true;
                        x = xpp;
                    }

对应图例为:

201705040013_4

0

节点0作为1的左子节点插入,由于其父节点为黑色,不会插入后不会打破红黑树结构,直接插入即可:

201705040014

11

节点11作为12的左子节点,其父节点12为黑色,和0一样道理,直接插入:

201705040015

7

节点7作为2右子节点插入,红红冲突,其叔父节点0为红色,变色即可:

201705040016

19

节点19作为节点12的右子节点,直接插入:

201705040017_2

至此,整个过程已经完成了,最终结果如下:

201705040018


如果你对 Dubbo / Netty 等等源码与原理感兴趣,欢迎加入我的知识星球一起交流。长按下方二维码噢:


目前在知识星球更新了《Dubbo 源码解析》目录如下:

01. 调试环境搭建
02. 项目结构一览
03. 配置 Configuration
04. 核心流程一览

05. 拓展机制 SPI

06. 线程池

07. 服务暴露 Export

08. 服务引用 Refer

09. 注册中心 Registry

10. 动态编译 Compile

11. 动态代理 Proxy

12. 服务调用 Invoke

13. 调用特性 

14. 过滤器 Filter

15. NIO 服务器

16. P2P 服务器

17. HTTP 服务器

18. 序列化 Serialization

19. 集群容错 Cluster

20. 优雅停机

21. 日志适配

22. 状态检查

23. 监控中心 Monitor

24. 管理中心 Admin

25. 运维命令 QOS

26. 链路追踪 Tracing

... 一共 69+ 篇

目前在知识星球更新了《Netty 源码解析》目录如下:

01. 调试环境搭建
02. NIO 基础
03. Netty 简介
04. 启动 Bootstrap

05. 事件轮询 EventLoop

06. 通道管道 ChannelPipeline

07. 通道 Channel

08. 字节缓冲区 ByteBuf

09. 通道处理器 ChannelHandler

10. 编解码 Codec

11. 工具类 Util

... 一共 61+ 篇

目前在知识星球更新了《数据库实体设计》目录如下:

01. 商品模块
02. 交易模块
03. 营销模块
04. 公用模块

... 一共 17+ 篇

目前在知识星球更新了《Spring 源码解析》目录如下:

01. 调试环境搭建
02. IoC Resource 定位
03. IoC BeanDefinition 载入

04. IoC BeanDefinition 注册

05. IoC Bean 获取

06. IoC Bean 生命周期

... 一共 35+ 篇

EMD (经验模态分解) 在 C++ 中的实现指南 EMD 是由 Norden E. Huang 等人在1998年提出的一种适用于非线性和非平稳信号的分析方法。对称性:IMF 的上下包络对称。零交叉点:IMF 的零交叉点数量与极值点数量相同或相差一个。本文详细介绍了如何在C++中实现EMD,包括理论背景、算法步骤、代码实现和优化等内容。通过丰富的代码示例和详细的解释,希望能够帮助读者掌握EMD的基本原理,并能够在实际项目中灵活应用。未来,随着信号处理技术的不断发展,EMD及其变种(如EEMD、CEEMDAN等)将继续在各个领域发挥重要作用。 阅读详情

相关推荐

【嵌入式原理系列-第七篇】ld脚本实战:从零构建MCU内存布局

本文是一篇针对嵌入式开发者的实战指南,详细讲解了如何从零开始为MCU编写ld链接器脚本以构建自定义内存布局。文章以STM32F103C8T6为例,深入剖析了MEMORY和SECTIONS指令的用法,并提供了OTA分区、非易失数据存储等高级定制案例,帮助开发者解决实际工程中的Flash与RAM管理难题,实现对程序运行的深度掌控。

weixin_29271263的博客 251

【死磕Java并发】-----J.U.C之ConcurrentHashMap红黑树转换分析

原文出处http://cmsblogs.com/ 『chenssy』 在【死磕Java并发】—–J.U.C之Java并发容器:ConcurrentHashMap一文中详细阐述了ConcurrentHashMap的实现过程,其中有提到在put操作时,如果发现链表结构中的元素超过了TREEIFY_THRESHOLD(默认为8),则会把链表转换为红黑树,已便于提高查询效率。代码如下:if (binCoun

chenssy 的技术博客 1万+

Minio HTTPS证书配置实战:从申请到部署全流程

本文详细介绍了Minio HTTPS证书配置的全流程,从申请到部署,确保对象存储服务的安全性。内容包括证书类型选择、文件处理、服务配置调整及常见问题解决,帮助用户在生产环境中快速实现HTTPS加密传输,提升数据安全。

weixin_42638178的博客 433

ConcurrentHashMap的红黑树

红黑树是一种特殊的二叉树,主要用它存储有序的数据,提供高效的数据检索,时间复杂度为。个特性的二叉树都是红黑树,当有新的节点加入时,有可能会破坏其中一些特性,需要通。、从一个节点到该节点的子孙节点的所有路径包含相同个数的黑色节点;、如果一个节点是红色的,那么它的子节点必须是黑色的;指向红黑树中当前遍历到的节点,从根节点开始递归遍历,、当有新节点加入时,可能会破坏红黑树的特性,需要执行。,设置其颜色为黑色,最终二叉树如下:④、加入节点。的左节点是否为空,如果不为空,则把。的右节点是否为空,如果不为空,则把。

2301_76965813的博客 1031

避开命令行!在VMware vCenter 8.0图形化界面里搞定SSL证书续期全流程

本文详细介绍了在VMware vCenter 8.0图形化界面中完成SSL证书续期的全流程,包括计算机SSL证书、VMCA根证书和STS证书的管理。通过可视化操作,管理员无需使用命令行即可高效处理证书问题,确保vSphere环境的稳定运行。文章还提供了证书监控与预警配置的实用技巧,帮助用户提前规避证书过期风险。

weixin_27051161的博客 284

高温环境下RS485通信故障分析与MOS管解决方案

RS485通信作为工业控制领域的基础总线技术,其可靠性直接影响系统稳定性。在高温等恶劣环境下,传统三极管开关电路会因温度特性导致通信故障。通过分析三极管Ube电压随温度变化的特性,揭示了电路失效的物理原理。相比之下,MOS管作为电压控制型器件,具有温度稳定性好、功耗低等优势,更适合工业环境应用。本文通过一个发动机舱内RS485通信故障的实际案例,详细对比了三极管与MOS管在高温环境下的性能差异,并给出了具体的电路改进方案。该案例对工业通信接口设计具有普遍参考价值,特别适用于需要应对高温、振动等挑战性环境的硬

weixin_42612405的博客 407

【死磕Java并发】—–J.U.C之ConcurrentHashMap红黑树转换分析

红黑树 先看红黑树的基本概念:红黑树是一课特殊的平衡二叉树,主要用它存储有序的数据,提供高效的数据检索,时间复杂度为O(lgn)。红黑树每个节点都有一个标识位表示颜色,红色或黑色,具备五种特性: 每个节点非红即黑 根节点为黑色 每个叶子节点为黑色。叶子节点为NIL节点,即空节点 如果一个节点为红色,那么它的子节点一定是黑色 从一个节点到该节点的子孙节点的所有路径包含相同个数的黑色节点 请牢记这五...

Elon Zero的博客 255

分区补光与ISP图像调节技术

在安防监控场景中,逆光、强光、明暗不均(如门口 / 窗边的 “阴阳脸” 画面)是导致图像细节丢失的核心问题。分区补光技术通过对画面不同亮度区域精准补光,解决 “局部过曝 / 欠曝” 难题;ISP(图像信号处理器)图像调节技术则通过算法优化,提升画面色彩、对比度与细节。二者协同可实现 “硬件补光 + 算法优化” 的双重增强,是低功耗摄像机实现高清画质的关键技术组合。分区补光与 ISP 图像调节技术:原理、协同方案及安防监控应用案例。一、核心技术原理解析。

AIoT深度探索者 | 嵌入式系统架构师 深耕物联网(IoT)与人工智能(AI)融合技术,聚焦​​边缘计算、图像开发、低功耗通信协议​​,致力于智能硬件,关注我获取最新技术文章信息与海量资源~ 733

红黑树简介,以及ConcurrentHashMap如何平衡红黑树

ConcurrentHashMap基础 1,ConcurrentHashMap维护了一个Node数组(JDK1.8),保存了各节点链表的头节点。 2,当链表长度超过8时,ConcurrentHashMap会考虑把链表转为红黑树,但不一定真的转。 3,当链表长度超过8,但Node数组长度小于64时,优先考虑数组扩容。如果Node数组长度大于64,则把链表转为红黑树。 红黑树基础 红黑树是一种近似平衡的二叉查找树,它并非绝对平衡,但是可以保证任何一个节点的左右子树的高度差不会超过二者中较低...

lkforce 1612

检索增强生成(RAG)、微调(Fine-tuning)与知识蒸馏(Knowledge Distillation):核心差异与技术选型指南

在自然语言处理(NLP)领域,大型预训练语言模型(如GPT、BERT系列)的崛起彻底改变了技术生态。面对实际业务场景中模型效果优化与资源效率平衡的永恒命题,开发者主要依赖三大技术路径:检索增强生成(Retrieval-Augmented Generation, RAG)、模型微调(Fine-tuning)和知识蒸馏(Knowledge Distillation)。本文将通过技术原理拆解、典型应用场景对比和实战选型策略三个维度,深入解析这三种技术的本质差异。

fudaihb的博客 1829

MOSFET雪崩特性参数解析

但是,一些电源在输出短路时,初级中会产生较大的电流,加上初级电感,器件就会有雪崩损坏的可能,因此在这样的应用条件下,就要考虑器件的雪崩能量。对于那些在MOSFET的D和S极产生较大电压的尖峰应用,就要考虑器件的雪崩能量,电压的尖峰所集中的能量主要由电感和电流所决定,因此对于反激的应用,MOSFET关断时会产生较大的电压尖峰。雪崩击穿能量标定了器件可以容忍的瞬时过冲电压的安全值,其依赖于雪崩击穿需要消散的能量。EAS单脉冲雪崩击穿能量, EAS标定了器件可以安全吸收反向雪崩击穿能量的高低。

Airer_00的博客 815

JDK、JRE与JVM的区别与联系

前言 现在Java程序员面试都是因为没有丰富的工作经验和自己过硬的技术,所有都不知道一般互联网应该会问什么技术问题,加上自己可能去面试的时候没有准备的太充分,一面试刚跟面试官扯几个面试题就不知道自己在哪里了,被怼的体无完肤了,最后以灰头土脸的结束,所有针对这类的读者,我把几个群友大厂面试时候的经历和面试题整理出来,再次分享给广大的朋友们去参考,让你们更加的了解一线大厂都是问的什么问题。 基础 JAVA基础 JAVA集合 JAVA多线程并发 网络 数据结构与算法 框架 Spring Spring

m0_57983600的博客 222

9 硬件工程师笔面试高频知识考点真题解析——运算放大器

运算放大器(运放)摘要 运放是一种高增益、差分输入的模拟集成电路,具有虚短(线性区输入电压相等)和虚断(输入电流为零)特性,支持负反馈(线性放大)和开环/正反馈(饱和区比较)两种工作模式。关键特性包括高输入阻抗、低输出阻抗,理想运放参数(如无限增益)与实际参数(如有限带宽)的差异。 选型要点: 信号特性:直流/低频信号关注失调电压(Vos)、温漂;高频信号侧重带宽(GBW)和压摆率(SR)。 电源条件:单/双电源供电、电压范围及功耗需求(如电池设备需低静态电流)。 精度与噪声:微弱信号需低噪声运放,高精度场

XU157303764的博客 1681

死磕 Java 并发

作者 :大明哥 博客 :http://cmsblogs.com/?cat=151 目录 : 《【死磕 Java 并发】—– 深入分析 synchronized 的实现原理》 《【死磕 Java 并发】—– 深入分析 volatile 的实现原理》 《【死磕 Java 并发】—– Java 内存模型之 happens-before》 《【死磕 Java 并发】—– Java 内存模...

scofen的博客 787

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

【死磕 Java 并发】—– J.U.C 之 Java并发容器:ConcurrentHashMap

点击上方“芋道源码”,选择“置顶公众号”技术文章第一时间送达!源码精品专栏 精尽 Dubbo 原理与源码 69 篇精尽 Netty 原理与源码 61 篇中文详细注释的开源...

芋道源码 240

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

ConcurrentHashMap的源码分析-treeifyBin

在putVal的最后部分,有一个判断,如果链表长度大于8,那么就会触发扩容或者红黑树的转化操作。 private final void treeifyBin(Node<K,V>[] tab, int index) { Node<K,V> b; int n, sc; if (tab != null) { if ((n = tab.length) < MIN_TREEIFY_CAPACITY) //tab的长度是不是小于64,如果是,则执行扩容 tryPr

Leon_Jinhai_Sun的博客 352

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

ConcurrentHashMap与红黑树实现分析Java8

本文学习知识点 1、二叉查找树,以及二叉树查找带来的问题。 2、平衡二叉树及好处。 3、红黑树的定义及构造。 4、ConcurrentHashMap中红黑树的构造。 在正式分析红黑树之前,有必要了解红黑树的发展过程,请读者耐心阅读。 二叉查找树 红黑树的起源得从二叉查找树(二叉排序树)说起。先来看二叉查找树的定义: 1、要么为一颗空树,要么就是一颗具有如下特性的二叉树。 2、左子节点

Oversdownload的博客 1334

HashMap红黑树原理及源码分析---图形、注释一应俱全

一、红黑树定义 红黑树是一种结点带有颜色属性的二叉查找树,除此还有以下5大性质: 节点是红色或黑色。 根是黑色。 所有叶子都是黑色(叶子是NIL节点,这类节点不可以忽视,否则代码会看不懂)。 每个红色节点必须有两个黑色的子节点。(从每个叶子到根的所有路径上不能有两个连续的红色节点。) 从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点(黑色平衡)。 NIL节点:为了红黑树平衡而添加的空节点 二、节点新增原理: 如果插入的是第一个节点(根节点),红色变黑色。-----基

持续学习,共同进步 7621

深入分析HashMap

一、传统HashMap的缺点 (1)JDK 1.8 以前 HashMap 的实现是 数组+链表,即使哈希函数取得再好,也很难达到元素百分百均匀分布。 (2)当 HashMap 中有大量的元素都存放到同一个桶中时,这个桶下有一条长长的链表,这个时候 HashMap 就相当于一个单链表,假如单链表有 n 个元素,遍历的时间复杂度就是 O(n),完全失去了它的优势。 (3)针对这种情况,JDK 1.8 中引入了红黑树(查找时间复杂度为 O(logn)来优化这个问题。 二、JDK1.8 中 HashMap 的数据结

云想衣裳花想容,春风拂槛露华浓 348

HashMap、ConcurrentHashMap、CopyOnWrite机制学习总结

HashMap、ConcurrentHashMap、CopyOnWrite机制学习总结

weixin_45161367的博客 685

ConcurrentHashMap常见的问题

concurrentHashMap面试题

duanwendi的博客 1520

ConcurrentHashMap源码解析6.TreeBin类

1.回顾 我们知道,当一个桶位形成了红黑树时,此时桶位中存的是一个TreeBin节点,其内部存在两个引用,分别是指向双向链表的first和指向红黑树根节点的r。 2.属性 /* * TreeBin继承了Node。其也有hash值(为-2) */ static final class TreeBin<K,V> extends Node<K,V> { //红黑树根节点 TreeNode<K,

KKK 1208

ConcurrentHashMap(JDK1.8)中红黑树的实现

ConcurrentHashMap(JDK1.8)中红黑树的实现

有问题的请私信或关注v【技术印记】留言 865

JUC篇·Java 中的 ConcurrentHashMap 与红黑树:深入解析与应用

ConcurrentHashMap 属于 Java 的 java.util.concurrent(JUC)并发包。JUC(java.util.concurrent)包是 Java 中用于处理并发编程的核心工具包。它提供了一系列高效、灵活且线程安全的类和接口,帮助开发者解决多线程环境下数据共享和同步的问题。在现代多核处理器的背景下,有效地利用并发编程可以显著提高程序的性能,而 JUC 包就是实现这一目标的关键所在。在Java的并发编程世界里,ConcurrentHashMap和红黑树都是极为重要的元素。

无所不能的开花组❀ 974

ConcurrentHashMap-红黑树

中的红黑树通过精细的平衡调整(旋转、颜色翻转)和并发控制(锁、CAS),在保证线程安全的同时,提供了高效的查找性能。理解其源码需结合树的结构特性与并发编程技巧,是深入掌握 Java 并发集合类的关键。

weixin_49622776的博客 1167
上一篇: 再谈 HBase 八大应用场景
下一篇: 演化:这五年里,我们对架构师职责的思考与定位
公众号-芋道源码
博客等级 码龄10年 1640粉丝 377原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值