Java 8 ConcurrentHashMap 源码分析

news2024/11/16 6:40:14

文章目录

  • 1. ConcurrentHashMap 的底层结构
  • 2. ConcurrentHashMap 的元素存储过程
  • 3. ConcurrentHashMap 的扩容
      • 3.1 扩容的过程
      • 3.2 源码分析

1. ConcurrentHashMap 的底层结构

JDK 1.8 的 ConcurrentHashMap 底层数据结构与 HashMap 基本相同，二者在容量机制、Entry 的 hash 值计算及数组 index 下标定位等方面几乎完全一致，这部分读者如感兴趣可参考 Java 8 HashMap 详解

2. ConcurrentHashMap 的元素存储过程

ConcurrentHashMap#putVal() 方法源码如下，从中可以看到其处理有以下几个关键步骤：

  1. ConcurrentHashMap 不支持 null 键 null 值
  2. 调用 ConcurrentHashMap#spread() 方法重新计算当前 key 的 hash，核心是高低 16 位异或增大 hash 离散程度
  3. 将 volatile 变量 table 赋值暂存为 tab，for 循环进行元素存储的处理
    1. 首先判断底层数组是否已经初始化，如果没有则调用 ConcurrentHashMap#initTable() 方法先初始化数组
    2. 根据 key 的 hash 运算确定一个数组下标，调用 ConcurrentHashMap#tabAt() 方法取得该数组下标上的第一个元素，如果该元素为 null 则不存在冲突，直接调用 ConcurrentHashMap#casTabAt() 方法 CAS 插入元素
    3. 如果数组下标第一个元素的 hash 值为 MOVED（-1），说明这个元素为 ForwardingNode 节点，该节点的存在表明 ConcurrentHashMap 正在扩容中，则此次循环无法插入元素，调用 ConcurrentHashMap#helpTransfer() 方法帮助扩容，直到扩容完成才能继续插入元素
    4. 如果数组下标第一个元素与当前 key 存在 hash 冲突，此时使用 synchronized 锁住该元素，如果该元素为链表节点，则直接将新元素封装到节点中插入链表末尾即可；如果该元素为树节点的封装对象，则说明这个下标位置上的链表已经转化为红黑树，调用红黑树的插入方法即可。元素插入后，如果检查到当前数组下标上的链表节点总数已经达到 8 个，则需调用 ConcurrentHashMap#treeifyBin() 方法尝试将其转化为红黑树
  4. 元素存储完毕， 调用 ConcurrentHashMap#addCount() 方法更新元素计数器。如果需要进行扩容检查，则校验当前元素总数是否大于容量控制阈值 sizCtl，是则进行扩容
    final V putVal(K key, V value, boolean onlyIfAbsent) {
        if (key == null || value == null) throw new NullPointerException();
        int hash = spread(key.hashCode());
        int binCount = 0;
        for (Node<K,V>[] tab = table;;) {
            Node<K,V> f; int n, i, fh;
            if (tab == null || (n = tab.length) == 0)
                tab = initTable();
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
                if (casTabAt(tab, i, null,
                             new Node<K,V>(hash, key, value, null)))
                    break;                   // no lock when adding to empty bin
            }
            else if ((fh = f.hash) == MOVED)
                tab = helpTransfer(tab, f);
            else {
                V oldVal = null;
                synchronized (f) {
                    if (tabAt(tab, i) == f) {
                        if (fh >= 0) {
                            binCount = 1;
                            for (Node<K,V> e = f;; ++binCount) {
                                K ek;
                                if (e.hash == hash &&
                                    ((ek = e.key) == key ||
                                     (ek != null && key.equals(ek)))) {
                                    oldVal = e.val;
                                    if (!onlyIfAbsent)
                                        e.val = value;
                                    break;
                                }
                                Node<K,V> pred = e;
                                if ((e = e.next) == null) {
                                    pred.next = new Node<K,V>(hash, key,
                                                              value, null);
                                    break;
                                }
                            }
                        }
                        else if (f instanceof TreeBin) {
                            Node<K,V> p;
                            binCount = 2;
                            if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                           value)) != null) {
                                oldVal = p.val;
                                if (!onlyIfAbsent)
                                    p.val = value;
                            }
                        }
                    }
                }
                if (binCount != 0) {
                    if (binCount >= TREEIFY_THRESHOLD)
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
        addCount(1L, binCount);
        return null;
    }

  1. ConcurrentHashMap#initTable() 方法逻辑比较简单，重要逻辑如下：

    1. 如果底层数组 table 尚未初始化，则进入 while 循环
    2. 根据容量控制阈值 sizeCtl 确定当前是否有其他线程在进行初始化操作，如果该值为 -1 表示其他线程正在初始化中，则当前线程让出 CPU 资源，以便初始化操作尽快完成
    3. 如果调用 Unsafe#compareAndSwapInt() 更新 sizeCtl 为 -1 成功，则当前线程执行底层数组的创建，并将 sizeCtl 重置为底层数组长度的 0.75 倍，作为扩容阈值来使用
    private final Node<K,V>[] initTable() {
     Node<K,V>[] tab; int sc;
     while ((tab = table) == null || tab.length == 0) {
         if ((sc = sizeCtl) < 0)
             Thread.yield(); // lost initialization race; just spin
         else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
             try {
                 if ((tab = table) == null || tab.length == 0) {
                     int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                     @SuppressWarnings("unchecked")
                     Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                     table = tab = nt;
                     sc = n - (n >>> 2);
                 }
             } finally {
                 sizeCtl = sc;
             }
             break;
         }
     }
     return tab;
 }

  2. ConcurrentHashMap#treeifyBin() 方法逻辑比较简练，首先判断底层数组的长度是否小于 64，如是则调用 ConcurrentHashMap#tryPresize() 方法尝试 2 倍扩容；其次如果当前数组下标的第一个元素仍然是链表节点，则锁住该节点，将当前链表转化为树节点链表，最终在 TreeBin 构造方法中完成红黑树构造

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

 private final void tryPresize(int size) {
     int c = (size >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY :
         tableSizeFor(size + (size >>> 1) + 1);
     int sc;
     while ((sc = sizeCtl) >= 0) {
         Node<K,V>[] tab = table; int n;
         if (tab == null || (n = tab.length) == 0) {
             n = (sc > c) ? sc : c;
             if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
                 try {
                     if (table == tab) {
                         @SuppressWarnings("unchecked")
                         Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                         table = nt;
                         sc = n - (n >>> 2);
                     }
                 } finally {
                     sizeCtl = sc;
                 }
             }
         }
         else if (c <= sc || n >= MAXIMUM_CAPACITY)
             break;
         else if (tab == table) {
             int rs = resizeStamp(n);
             if (sc < 0) {
                 Node<K,V>[] nt;
                 if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                     sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
                     transferIndex <= 0)
                     break;
                 if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
                     transfer(tab, nt);
             }
             else if (U.compareAndSwapInt(this, SIZECTL, sc,
                                          (rs << RESIZE_STAMP_SHIFT) + 2))
                 transfer(tab, null);
         }
     }
 }

  3. ConcurrentHashMap#addCount() 方法首先通过 Unsafe 更新元素计数器，其次如果入参指定了需要检查扩容则判断元素总数是否大于 sizeCtl 容量阈值，如果是则需要进入扩容操作。这里的关键逻辑如下：

    1. 当扩容操作还未开始时，sizeCtl 还存储着容量阈值，此时其为正数，由当前线程使用 Unsafe 将其更新为特定算法计算出来的负数后，再调用 ConcurrentHashMap#transfer() 开始扩容操作
    2. 当 sizeCtl 为负数时，说明扩容操作已经开始了，此时由当前线程使用 Unsafe 将其加 1 作为扩容线程计数，然后调用 ConcurrentHashMap#transfer() 传入扩容操作的缓存数组 nextTable 进行后续扩容操作
     private final void addCount(long x, int check) {
     CounterCell[] as; long b, s;
     if ((as = counterCells) != null ||
         !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
         CounterCell a; long v; int m;
         boolean uncontended = true;
         if (as == null || (m = as.length - 1) < 0 ||
             (a = as[ThreadLocalRandom.getProbe() & m]) == null ||
             !(uncontended =
               U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
             fullAddCount(x, uncontended);
             return;
         }
         if (check <= 1)
             return;
         s = sumCount();
     }
     if (check >= 0) {
         Node<K,V>[] tab, nt; int n, sc;
         while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
                (n = tab.length) < MAXIMUM_CAPACITY) {
             int rs = resizeStamp(n);
             if (sc < 0) {
                 if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                     sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
                     transferIndex <= 0)
                     break;
                 if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
                     transfer(tab, nt);
             }
             else if (U.compareAndSwapInt(this, SIZECTL, sc,
                                          (rs << RESIZE_STAMP_SHIFT) + 2))
                 transfer(tab, null);
             s = sumCount();
         }
     }
 }

3. ConcurrentHashMap 的扩容

3.1 扩容的过程

从源码来看，ConcurrentHashMap 的扩容时机主要有以下两个：

  1. ConcurrentHashMap 的元素总数大于容量控制阈值 sizeCtl
  2. 某个数组下标上的链表元素数量达到树化阈值 8，但是当前底层数组的长度小于 64

整个扩容从触发到处理的过程示意如下，关键步骤做如下补充：

  1. 当线程 A 添加元素到 ConcurrentHashMap 后，检查发现当前 Map 中的元素总数达到扩容阈值，则触发扩容操作
  2. 扩容时每条线程每次都只负责一部分下标的元素迁移，迁移进度由偏移量 transferIndex 控制，该值初始化为底层数组长度
  3. 根据 CPU 核数和底层数组长度，分配每轮迁移数组下标的数量，最小为 16。确定该跨度值后，结合 transferIndex 就可以确定当前线程本轮负责迁移的数组下标范围，此时从数组尾部开始进行迁移工作
  4. 线程 A 迁移过程中会在原数组每一个迁移完成的下标上留下一个 Forwarding 节点作为标记，当其他线程识别到标记节点时需要做对应处理。例如线程 B 添加元素时，发现数组下标上的元素是 Forwarding 节点，则知道当前正在扩容中，需要帮助扩容；当线程 B 获取元素时，在该下标上发现了 Forwarding 节点，则说明该下标上的元素都迁移到了新数组，这时候就要调用 ForwardingNode#find() 去新数组查找获取元素
  5. 扩容的进程由 sizeCtl 控制，每多一个线程加入扩容，该值都会加 1。如果没有其他线程加入扩容，则单条线程会在在迁移方法不断将元素移动到新数组，直到 transferIndex 为 0
  6. 当 transferIndex 为 0 时，数组上已经没有元素要迁移了，则每条线程退出扩容时将sizeCtl 复位。当 sizeCtl 值复位为原负数时，说明这条线程就是最后一条扩容线程，则执行扩容结束后的操作，从尾部开始重新检查原数组中是否有遗漏未迁移的元素，完成后使用迁移后的 nextTable 替换原数组，并将 sizeCtl 值重新赋值为新数组的扩容阈值

在这里插入图片描述

3.2 源码分析

扩容的触发点比较多，但是无论从哪里触发，最终调用的都是 ConcurrentHashMap#transfer() 方法。需要注意的是，在每条线程加入扩容之前都会通过 U.compareAndSwapInt(this, SIZECTL, sc, sc + 1) 借助 Unsafe 类在 sizeCtl 上计数，该变量在扩容时主要作用是确保由最后一条退出扩容的线程来完成迁移遗漏检查和数组替换。ConcurrentHashMap#transfer() 方法源码如下，可以看到处理大致划分为以下几个部分：

  1. 根据 CPU 核心数确定每轮迁移数组下标数量，最小为 16
  2. 如果新数组 nextTab 还没有创建，则按原数组长度 2 倍创建新数组，并初始化 transferIndex 偏移量为原数组长度
  3. for 循环中进行迁移处理的代码大致分为以下几个部分：
    1. 首先在 while 循环中完成本轮迁移数组下标范围的确定，之后每迁移完一个数组下标则将右边界 i 左移，直到 transferIndex 偏移量为 0，将右边界 i 赋值为 -1
    2. 根据右边界 i 的值计算当前线程本次扩容是否结束。在这部分中，首先通过 U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1) 复位 sizeCtl 上计数。根据该变量的计算结果确定当前线程是否是最后一条退出扩容的线程，如果是则更新标识位 finishing，将右边界 i 赋值为原数组长度，从原数组尾部重新检查迁移是否有遗漏。当检查完毕，根据标识位 finishing 使用新数组替换原数组完成扩容
    3. 右边界 i 从右往左移动，如果遍历过程中原数组下标 i 上没有元素，则只需要在该位置插一个 Forwarding 节点作为标记即可。如果该位置上的元素已经是 Forwarding 节点，则将 advance 置为 true，跳过处理即可。如果在数组下标 i 上存在需要迁移的元素，则先用 synchronized 锁住其头节点，按照数据结构的不同做对应的迁移处理即可，迁移完成后在原数组下标位置留一个 Forwarding 节点作为标记。此处确定元素在新数组下标的算法可以参考 HashMap 扩容机制
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
        int n = tab.length, stride;
        if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
            stride = MIN_TRANSFER_STRIDE; // subdivide range
        if (nextTab == null) {            // initiating
            try {
                @SuppressWarnings("unchecked")
                Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
                nextTab = nt;
            } catch (Throwable ex) {      // try to cope with OOME
                sizeCtl = Integer.MAX_VALUE;
                return;
            }
            nextTable = nextTab;
            transferIndex = n;
        }
        int nextn = nextTab.length;
        ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
        boolean advance = true;
        boolean finishing = false; // to ensure sweep before committing nextTab
        for (int i = 0, bound = 0;;) {
            Node<K,V> f; int fh;
            while (advance) {
                int nextIndex, nextBound;
                if (--i >= bound || finishing)
                    advance = false;
                else if ((nextIndex = transferIndex) <= 0) {
                    i = -1;
                    advance = false;
                }
                else if (U.compareAndSwapInt
                         (this, TRANSFERINDEX, nextIndex,
                          nextBound = (nextIndex > stride ?
                                       nextIndex - stride : 0))) {
                    bound = nextBound;
                    i = nextIndex - 1;
                    advance = false;
                }
            }
            if (i < 0 || i >= n || i + n >= nextn) {
                int sc;
                if (finishing) {
                    nextTable = null;
                    table = nextTab;
                    sizeCtl = (n << 1) - (n >>> 1);
                    return;
                }
                if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
                    if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
                        return;
                    finishing = advance = true;
                    i = n; // recheck before commit
                }
            }
            else if ((f = tabAt(tab, i)) == null)
                advance = casTabAt(tab, i, null, fwd);
            else if ((fh = f.hash) == MOVED)
                advance = true; // already processed
            else {
                synchronized (f) {
                    if (tabAt(tab, i) == f) {
                        Node<K,V> ln, hn;
                        if (fh >= 0) {
                            int runBit = fh & n;
                            Node<K,V> lastRun = f;
                            for (Node<K,V> p = f.next; p != null; p = p.next) {
                                int b = p.hash & n;
                                if (b != runBit) {
                                    runBit = b;
                                    lastRun = p;
                                }
                            }
                            if (runBit == 0) {
                                ln = lastRun;
                                hn = null;
                            }
                            else {
                                hn = lastRun;
                                ln = null;
                            }
                            for (Node<K,V> p = f; p != lastRun; p = p.next) {
                                int ph = p.hash; K pk = p.key; V pv = p.val;
                                if ((ph & n) == 0)
                                    ln = new Node<K,V>(ph, pk, pv, ln);
                                else
                                    hn = new Node<K,V>(ph, pk, pv, hn);
                            }
                            setTabAt(nextTab, i, ln);
                            setTabAt(nextTab, i + n, hn);
                            setTabAt(tab, i, fwd);
                            advance = true;
                        }
                        else if (f instanceof TreeBin) {
                            TreeBin<K,V> t = (TreeBin<K,V>)f;
                            TreeNode<K,V> lo = null, loTail = null;
                            TreeNode<K,V> hi = null, hiTail = null;
                            int lc = 0, hc = 0;
                            for (Node<K,V> e = t.first; e != null; e = e.next) {
                                int h = e.hash;
                                TreeNode<K,V> p = new TreeNode<K,V>
                                    (h, e.key, e.val, null, null);
                                if ((h & n) == 0) {
                                    if ((p.prev = loTail) == null)
                                        lo = p;
                                    else
                                        loTail.next = p;
                                    loTail = p;
                                    ++lc;
                                }
                                else {
                                    if ((p.prev = hiTail) == null)
                                        hi = p;
                                    else
                                        hiTail.next = p;
                                    hiTail = p;
                                    ++hc;
                                }
                            }
                            ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) :
                                (hc != 0) ? new TreeBin<K,V>(lo) : t;
                            hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :
                                (lc != 0) ? new TreeBin<K,V>(hi) : t;
                            setTabAt(nextTab, i, ln);
                            setTabAt(nextTab, i + n, hn);
                            setTabAt(tab, i, fwd);
                            advance = true;
                        }
                    }
                }
            }
        }
    }

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/518336.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

测试的分类（按测试对象、是否查看代码、开发阶段、实施组织...... + 思维导图总结）

测试的分类（按测试对象、是否查看代码、开发阶段、实施组织...... + 思维导图总结）

目录 一、测试的分类 1. 按测试对象划分 2. 按照是否查看代码划分 3. 按照开发阶段划分 4. 按照测试实施组织划分 5. 按照是否运行划分 6. 按照是否手工划分 7. 按照地域划分 二、总结 一、测试的分类 1. 按测试对象划分 &#xff08;1&#xff09;界面测试 简称UI测…
阅读更多...
Centos配置OpenVPN+OpenLDAP认证

Centos配置OpenVPN+OpenLDAP认证

Centos配置OpenVPNOpenLDAP认证 一、安装openvpn-auth-ldap插件二、配置ldap.conf文件三、配置openvpn中的server.conf文件四、配置客户端client.ovpn文件五、开启路由转发功能六、脚本编辑七、测试 Centos搭建OpenVPN的环境有很多资料&#xff0c;自行查询配置 一、安装openv…
阅读更多...
工作两年了，不想做客服，转行学数据分析改变未来！

工作两年了，不想做客服，转行学数据分析改变未来！

不想做客服&#xff0c;转行学数据分析改变未来&#xff01; 从今年开年以来&#xff0c;已经接触了很多转行人群的课程咨询&#xff0c;其中比较有代表性的原职业就是客服&#xff0c;听到对职业的抱怨大多是&#xff1a;工作辛苦&#xff0c;待遇又低&#xff0c;又没前途&am…
阅读更多...
基于WiFi的CSI数据做呼吸频率检测-python版

基于WiFi的CSI数据做呼吸频率检测-python版

一、概述 本Demo无需机器学习模型&#xff0c;Demo功能涉及的理论主要参考了硕士学位论文《基于WiFi的人体行为感知技术研究》&#xff0c;作者是南京邮电大学的朱XX&#xff0c;本人用python复现了论文中呼吸频率检测的功能。Demo实现呼吸速率检测的主要过程为&#xff1a; …
阅读更多...
15-721 chapter12 查询计划

15-721 chapter12 查询计划

查询模型 查询模型就是定义如何支持服务端多个并发服务&#xff0c;这里我们引入了worker的抽象概念&#xff0c;可以是线程也可以是进程&#xff0c;就是支持客户端请求并且返回结果的。 进程模型 进程池模型 不利于cache,并且进程之间的通信依赖于tcp&#xff0c;shared me…
阅读更多...
外贸独立站必备神器AB斗篷

外贸独立站必备神器AB斗篷

做独立站仿品的都知道&#xff0c;如果需要在FB、Google等平台上打广告&#xff0c;必须先上正品才能通过审核&#xff0c;而且就算通过了审核&#xff0c;后期平台也会不定期地去检查。所以当平台的审核爬虫来&#xff0c;商家必须先跳到正品网页规避审核&#xff0c;当买家过…
阅读更多...
FE_Vue学习笔记 - 模板语法[插值 指令] 数据绑定[v-bind v-model] 数据代理 事件

FE_Vue学习笔记 - 模板语法[插值 指令] 数据绑定[v-bind v-model] 数据代理 事件

尝试 Vue.js 最简单的方法是使用 Hello World 例子&#xff0c;你可以在浏览器新标签页中打开它&#xff0c;跟着例子学习一些基础用法&#xff0c;或者你也可以创建一个 .html 文件&#xff0c;然后通过如下方式引入 Vue&#xff1a; <!-- 开发环境版本&#xff0c;包含了…
阅读更多...
Java-Redis缓存穿透，击穿，雪崩和布隆算法

Java-Redis缓存穿透，击穿，雪崩和布隆算法

Java-Redis缓存穿透&#xff0c;击穿&#xff0c;雪崩和布隆算法 1.缓存穿透概念:2.如何解决缓存穿透:3.什么是缓存击穿?4.什么是缓存雪崩?5.导致缓存雪崩的原因:6.缓存穿透&#xff0c;缓存击穿&#xff0c;缓存雪崩的区别: 1.缓存穿透概念: 当一个用户想要查询数据时&…
阅读更多...
一文解析Menu Governor

一文解析Menu Governor

在现代操作系统中&#xff0c;往往很多时候并不需要去执行cpu密集型的任务&#xff0c;而每当这个时候&#xff0c;如果去持续的执行循环去等待新的任务发过来&#xff0c;那需要消耗巨大的能量。所以设计人员设计出一种空闲状态以此CPU进入低功耗模式。在Linux系统中&#xff…
阅读更多...
智能运维的集中告警平台实战思路 —— 紧耦合还是宽融合？

智能运维的集中告警平台实战思路 —— 紧耦合还是宽融合？

作者&#xff1a;擎创科技产品总监 Daniel 本文是节选&#xff0c;如感兴趣可留言一起探讨。 &#xff08; 我们在确定一个产品的思路和方向时&#xff0c;经常面临截然不同的选择。如同此文探讨的集中告警平台是否应跟集中监控平台紧绑定或松融合&#xff0c;具体的实战案例…
阅读更多...
[译] Dart 3 发布了

[译] Dart 3 发布了

[译] Dart 3 发布了 原文 https://medium.com/dartlang/announcing-dart-3-53f065a10635 https://ducafecat.com/blog/dart-3 来自 Google I/O 2023 的问候。今天&#xff0c;我们在 Mountain View 现场宣布 Dart 3——迄今为止最大的 Dart 发布&#xff01;Dart 3 包含三个主要…
阅读更多...
Springboot +Flowable，各种历史信息如何查询（一）

Springboot +Flowable，各种历史信息如何查询（一）

一.简介 正在执行的流程信息是保存在以 ACT_RU_ 为前缀的表中&#xff0c;执行完毕的流程信息则保存在以 ACT_HI_ 为前缀的表中&#xff0c;也就是流程历史信息表。 假设有一个流程&#xff0c;流程图如下&#xff1a; 当这个流程执行完毕后&#xff0c;以 ACT_RU_ 为前缀的…
阅读更多...
小黑子—多媒体技术与运用基础知识三：数字图形图像处理技术

小黑子—多媒体技术与运用基础知识三：数字图形图像处理技术

多媒体技术与运用3.0 多媒体系列第三章1. 颜色科学1.1 颜色的性质1.1.1 颜色的物理性质1.1.2颜色三特性1.1.3三原色与三补色 1.2 颜色空间1.2.1 与设备无关的颜色空间1.2.1 与设备相关的颜色空间 1.3 常见的多媒体系统颜色空间1.3.1 RGB颜色空间1.3.2 CMYK颜色模型1.3.3 HSB颜色…
阅读更多...
什么是模型鲁棒性和泛化能力

什么是模型鲁棒性和泛化能力

目录 1、鲁棒性 2、泛化能力 1、鲁棒性 定义&#xff1a;在统计学领域和机器学习领域&#xff0c;对异常值也能保持稳定、可靠的性质&#xff0c;称为鲁棒性。比如说&#xff0c;计算机软件在输入错误、磁盘故障、网络过载或有意攻击情况下&#xff0c;能否不死机、不崩溃&a…
阅读更多...
17 KVM虚拟机配置-XML配置文件示例

17 KVM虚拟机配置-XML配置文件示例

文章目录 17 KVM虚拟机配置-XML配置文件示例17.1 概述17.2 示例一17.3 示例二 17 KVM虚拟机配置-XML配置文件示例 17.1 概述 本节给出一个基本的AArch64虚拟机和一个x86_64虚拟机的XML配置文件示例&#xff0c;供参考。 17.2 示例一 一个包含基本元素的AArch64架构虚拟机的…
阅读更多...
Psychophysiology：降维独立成分分析(rdICA)对ERP测量的影响

Psychophysiology：降维独立成分分析(rdICA)对ERP测量的影响

导读 独立成分分析(ICA)是一种有效且普遍使用的EEG信号处理工具。为了减少计算时间&#xff0c;许多分析管道在ICA之前降低了EEG维数。Artoni及其同事(2018)的研究中就详细地描述了这种降维ICA(rdICA)对独立成分的偶极性和可靠性的有害影响。虽然ICA对于那些直接分析独立成分感…
阅读更多...
【网络安全】记一次网站站点渗透

【网络安全】记一次网站站点渗透

前言 遇到一个站&#xff0c;后端是 Node.js 写的&#xff0c;对于这种类型的站点&#xff0c;一般比较难 getshell&#xff0c;但也实现了最终的目标&#xff0c;拿到后台权限 信息搜集 先进行常规的信息搜集&#xff0c;子域名扫描、端口扫描、目录扫描等 这个站后端脚本语…
阅读更多...
如何实现文件共享，文件共享的设置方法-镭速

如何实现文件共享，文件共享的设置方法-镭速

文件共享是指在计算机网络中&#xff0c;多个用户可以通过共享相同的文件或目录来实现数据交换和协作工作。这种方式可以使多个用户在不同地点的计算机上访问并编辑同一个文件&#xff0c;从而实现更加高效和便捷的合作。 实现文件共享是计算机网络中常见的需求&#xff0c;可以…
阅读更多...
关于在 MySQL 排序中使用索引这件事！

关于在 MySQL 排序中使用索引这件事！

文章目录 1. 排序的两种方式2. 索引排序2.1 案例一2.2 案例二2.3 案例三2.4 案例四2.5 案例五2.6 案例六2.7 案例七2.8 案例八 3. 其他情况3.1 多表联查3.2 order by null 4. 小结 前面跟小伙伴们分享的索引相关的内容&#xff0c;基本上都是在 where 子句中使用索引&#xff0…
阅读更多...
java环境变量 的配置与详解

java环境变量 的配置与详解

笔者这学期开始学习java课程&#xff0c;学习java开发首先需要配置java运行环境变量。虽然上课老师也讲了如何配置java环境变量&#xff0c;可是笔者的同学还是有好多都不会配置&#xff0c;所以笔者最近配置了特别多次java环境变量。如下笔者详细解释从JDK安装到环境变量的装配…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023