【juc】cuncurrentHashMap 1.8 and 1.7实现概览

最新推荐文章于 2022-03-28 15:17:56 发布
最新推荐文章于 2022-03-28 15:17:56 发布
阅读量305 收藏
点赞数
分类专栏： java之路 知识点总结 文章标签： 链表 java 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40827685/article/details/120282832
版权

实现概览

jdk1.7之前的使用分段锁segment，每个segment内部是一个hashTable。jdk1.8用数组+链表+红黑树+CAS原子操作 实现 ConcurrentHashMap，也就是给么给线程分配一个桶的区间，并发扩容于转移。

HashTable

HashTable: synchronized对整个对象进行put等修改Hash时，进行加锁

jdk1.7的策略

在对象中保存了一个Segment数组，将整个Hash表划分成多个分段。每个Segment类似于一个HashTable。

每个Segment通过继承ReentrantLock进行加锁。所以每次锁住的是一个segment。segment数组无法扩容。

参数

  • concurrencyLevel: 并行级别、并发数、Segment的个数。默认为16.

  • initialCapacity：初始容量。整个ConcurrentHashMap的初始容量，实际操作需要平均分给每个Segment

-LoadFactor: 负载因子，默认0.75，给每个segment内部用的。Segment数组无法扩容，但是内部可以扩容。

初始化槽ensureSegment

并发操作使用CAS进行控制。

ConcurrentHashMap初始化会初始化第一个Segment[0], 对于其他槽，是在插入第一个槽的时候进行的初始化。
因为初始化其他槽的时候，需要用当前的segment[0]处的数组长度和负载因子进行初始化。

但是初始化某个槽segment[k]就涉及到多线程对他初始化。

首先检查这个segment是否被其他线程初始化了。如果没有，就设置一个while循环，while（没被初始化UNSAFE.getObjectVolatile，就循环内部CAS对segment赋值），直到当前线程成功设置or其他线程成功设置。

插入set

初始化得到一个Segment数组Segment<K, V>s。Segment[i]默认大小为2

插入节点到表头。

  1. hash（key）得到数组中的位置j: hash是32位，又因为concurrencyLevel=16，有16个segment, 因此高4位代表的数组下标。
  2. segment内部插入。segment内部是数组+链表。现获取segment独占锁。

并发：首先获取内部锁，是利用node=tryLock(), 如果获得成功，就利用scanAndLockForPut循环tryLock获得锁。失败次数超过阈值，就进入lock()阻塞队列等待。

get

没有加锁

问题：get的时候发生remove or put可能有问题。但是：添加节点是通过加到表头实现的。如果这个时候get操作在链表的遍历中已经到了中间，就不会影响。

volatile关键字可以保证put的时候的可见性。

限制

最大的并发度受Segment的个数限制。

JDK1.8

精髓：通过给每个线程分配一个桶的区间，进行并发式的扩容。

1.8没有用到分段锁segment。加锁使用CAS+Synchronized实现。 虽然也定义了Segment静态内部类，但JDK1.8中只有在（反）序列化方法中使用了这个类，只是为了（反）序列化时与JDK1.7相兼容而已。

容量大小：2的次幂：扩容的时候要保证是2的次幂。因为计算桶的hash值时，需要与容量-1（全1）想与得到。而不是取余。因此需要让容量-1为全1的数。

但是改革之后，计算hash的方法不是这种，而是用前16位与后16位与得到。

请添加图片描述

图片来源🔗：https://www.cnblogs.com/gocode/p/analysis-source-code-of-ConcurrentHashMap.html

重要常量

private static final int MIN_TRANSFER_STRIDE = 16; //多线程扩容时每个线程处理的最少哈希桶个数

private static final int DEFAULT_CONCURRENCY_LEVEL = 16;//默认并发线程数

static final int MOVED     = -1; // hash for forwarding nodes. 当前节点正在扩容、移除或重试。查找需要的nextTable上进行
static final int TREEBIN   = -2; // hash for roots of trees表示这个是红黑树
static final int RESERVED  = -3; // hash for transient reservations,为常量-3。用来保存

// 链表节点Node、红黑树节点TreeNode这两种正常节点的hash属性是非负数变量

关键数据结构

关键变量


1. sizeCtl

    当大于>0时，在initTable中可以用来初始化table容量,初始化之后，表示下次要扩容的阀值。<0,说明有其他进程在对初始化table中。|sizeCtl|=（1 +正在resize的线程数）
    
 /**
     * Table initialization and resizing control.  When negative, the
     * table is being initialized or resized: -1 for initialization,
     * else -(1 + the number of active resizing threads).  Otherwise,
     * when table is null, holds the initial table size to use upon
     * creation, or 0 for default. After initialization, holds the
     * next element count value upon which to resize the table.
     */
    private transient volatile int sizeCtl;

CAS和Synchronized都用在哪里了

CAS:

1. 修改sizeCtl的时候，使用CAS修改。(sizeCtl可以用来初始化table的大小)

Synchronized:

1. 锁住桶内部的头节点。（也就是将桶内的链表or红黑树锁住了，进行修改。

volatile：

1. 整个数组table是volatile的

put

找到hash值对应的数组下标。如果数组中这个桶为空，则直接CAS方式插入。如果CAS失败，则进入下一个循环。

1. 首先初始化table

再根据位运算“(n-1)& hash”取余求出table的索引i，并进一步获取table下标为i的元素f,此f代表一个哈希桶，它一个单向链表或红黑树。

2. 若桶是否是空的，里面链表头指针是null，直接CAS自旋进行初始化，初始化成功才可以退出循环.
3. 若f的hash是-1，`(fh = f.hash) == MOVED`则表明table正在resize,要调用helpTransfer加速扩容。helpTransfer方法结束后，自旋重试添加键值对 
4. 若f不为空且其hash也不是-1时,就使用阻塞锁（synchronized关键字）将对象f锁住，再遍历链表f，查找此链表上是否存在Key对应的节点e
5. 若f的数据结构是ReservationNode（说明正在执行comput方法）等其他类型节点就同样需要自旋重试，直到状态恢复正常。
6. 若是正常节点：
    - 判断头指针的hash值是否>0, 是否是链表`(fh = f.hash) >= 0`头节点hash值>0, 所以是链表。若插入后链表长度超过阈值，变成红黑树。
    - 是否是红黑树`f instanceof TreeBin`


/** Implementation for put and putIfAbsent */
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();
        // 找hash值对应的桶的下标，如果这个桶是空的，就直接CAS插入
        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
        }
        // 如果桶在的链表的hash值是moved，正在扩容
        else if ((fh = f.hash) == MOVED)
            // 帮助数据迁移，使用多线程的方式，迁移tab这一个桶的数据
            tab = helpTransfer(tab, f);
        // f是头节点, 并且没有进行数据迁移
        else {
            V oldVal = null;
            // 锁住该位置头节点
            synchronized (f) {
                if (tabAt(tab, i) == f) {
                    if (fh >= 0) { // 头节点hash值>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); // 如果长度<64, 则数组扩容，否则就转成红黑树
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    addCount(1L, binCount);
    return null;
}

链表转红黑树

// 不一定转红黑树，如果数组长度<64, 则直接进行数组扩容，否则转红黑树
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));
                }
            }
        }
    }
}

扩容：tryPresize

CAS的方法修改sizeCtl，然后循环执行, 调用多次transfer方法。第一次调用传入transfer的nextTab是null，是因为nextTab在不进行扩容或其他操作的时候是空的，在进行扩容的时候，作为备用数组使用。但是不涉及多线程调用transfer

/**
    * Tries to presize table to accommodate the given number of elements.
    *
    * @param size number of elements (doesn't need to be perfectly accurate)
    */
private final void tryPresize(int size) {
    // c: size 的 1.5 倍，再加 1，再往上取最近的 2 的 n 次方。
    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;
                // 调用transfer
                if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
                    transfer(tab, nt);
            }
            else if (U.compareAndSwapInt(this, SIZECTL, sc,
                                            (rs << RESIZE_STAMP_SHIFT) + 2))
                // 第一次调用transfer
                transfer(tab, null);
        }
    }
}

迁移数据Transfer

疑问： 一次移动多少的数据，是以index桶为单位吗，stride的作用？

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); // 使用这个构造方法构造的forwording节点，hash值为MOVED, next指向nextTab
    // 迁移完桶i的这个节点后，

    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，代表下次扩容的阈值
                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
            }
        }
        // 如果当前位置是空的，放入刚初始化的ForwardingNode空节点
        else if ((f = tabAt(tab, i)) == null)
            advance = casTabAt(tab, i, null, fwd);
        // 如果当前的已经是forwarding节点了, 表示已经迁移过
        else if ((fh = f.hash) == MOVED)
            advance = true; // already processed
        else {
            // 开始迁移，处理数组该位置的迁移工作
            synchronized (f) {
                if (tabAt(tab, i) == f) {
                    Node<K,V> ln, hn;
                    // hash大于0，说明是链表的Node节点，依然采用1.7中高低两个链表进行迁移
                    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);
                        // 将原数组该位置设置fwd, 代表这个位置已经处理完毕
                        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;
                            }
                        }
                        // 一分为二后，节点少于8，则转成链表
                        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;

                        // 将ln放置在相应的位置
                        setTabAt(nextTab, i, ln);
                        setTabAt(nextTab, i + n, hn);
                        setTabAt(tab, i, fwd);
                        advance = true;
                    }
                }
            }
        }
    }
}

参考文章

1. 参考文章总结
2. 参考博客
3. 源码

叩钉吧zz
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java高并发之Councurrent详解
不满是向上的车轮
05-12 587
最近将自己之前的知识整理整合一遍，防止遗漏忘记。 Concurrent concurrent包是jdk1.5开始所提供的一个针对高并发进行编程的包。 一.阻塞式队列 - BlockingQueue 遵循先进先出（FIFO）原则。阻塞式队列本身使用的时候需要指定界限。 1.ArrayBlockingQueue-阻塞式顺序队列 底层是基于数组来进行储存的，使用时需要指定一个容量，容量在指定之后不可改变。多用于生产-消费模型。 示例代码： public static void main(String[] args
1.7及1.8 Hashmap与ConcurrentHashMap详解
Al1en的博客
02-26 743
title: JUC.ConcurrentHashMap与HashMap 提纲 1.7HashMap 1.8HashMap 1.7ConcurrentHashMap 1.8ConcurrentHashMap 这一章东西比较多分开来写可以写四篇，所以不是一个晚上可以写完。我决定尽快在这两天写完。 这一章的内容推荐可以看看《码出高效》深入浅出，提高思维深入，摸着良心说。 对于代码中涉及到的复杂数...
Java 并发工具箱之concurrent包
BoBoMEe
02-27 2万+
概述java.util.concurrent 包是专为 Java并发编程而设计的包。包下的所有类可以分为如下几大类： locks部分：显式锁(互斥锁和速写锁)相关； atomic部分：原子变量类相关，是构建非阻塞算法的基础； executor部分：线程池相关； collections部分：并发容器相关； tools部分：同步工具相关，如信号量、闭锁、栅栏等功能； 类图结构：脑图地址： J.U.CB
ConcurrentHashMap简介
gulanga5的博客
03-07 5万+
一、jdk1.8之前的数据结构： 1.默认情况下会有16个区段 Segment数组 Segment[16] 2.每次每个区段Segment中会保存若干个散列桶，每次散列桶长度扩容成2^n次方的长度。 多个散列桶相连就构成了散列表。 3.存入元素： key带入到hashcode方法众获得hashcode值，然后把hashcode值带入到散列算法中获取segment的下标(区段编号)，再根据key带入到定义好的函数中获取Segment对象中散列桶的下标。 如果此位置有元素就构成链表(JDK1.8及以后会
ConcurrentHashMap
weixin_46574815的博客
03-21 1万+
引言 HashMap 在我们日常的开发中使用频率最高的一个工具类之一，然而使用 HashMap 最大的问题之一就是它是线程不安全的，如果我们想要线程安全, 这时候就可以选择使用 ConcurrentHashMap，ConcurrentHashMap 和 HashMap 的功能是基本一样的，ConcurrentHashMap 是 HashMap 的线程安全版本。 因 ConcurrentHashMap 和 HashMap 在 jdk1.8 版本中排除线程的安全性方面，其他的设计都很类似。 Concurrent
ConcurrentHashMap详解
唐芬奇的博客
03-28 8万+
文章目录spread()方法putVal()方法initTable()方法tryPresize()tableSizeFor()resizeStamp()transfer()总结compute()addCount() 计算成员数量sumCount()fullAddCount()资源锁sizeCtl其它节点类型forwarding节点ReservationNode节点 spread()方法 作用：用于获取槽位值 static final int spread(int h) { //h为k
jdk 1.8 ConcurrentHashMap和1.7 ConcurrentHashMap区别 原理解析
xqqTechnology的博客
05-31 596
@[TOC](`jdk 1.8 ConcurrentHashMap和1.7 ConcurrentHashMap区别 原理解析） #在上一篇文章中，我们详细链接了HashMap在1.7和1.8和实现区别，但是我们都知道HashMap在多线程下是不安全的，所以jdk也为我们提供了并发安全的容器进行使用，那就是我们这篇文章的主角：ConcurrentHashMap。 part1：1.7ConcurrentHashMap探索 我们首先看一下内部结构 从源码我们了解到，ConcurrentHashMap 是
JUC相关知识和底层实现原理分析.jpg
09-02
JUC底层实现原理分析，结构多线程更加贯彻同步知识
juc并发编程脑图以及相关示例代码
07-30
juc并发编程脑图以及相关示例代码
heima-JUC-资料
最新发布
04-25
Java并发编程是Java Util Concurrency（JUC）库的核心内容，它为多线程环境提供了高效、安全且灵活的工具和API。JUC是Java 5及后续版本引入的一个重要特性，极大地提升了Java在多处理器和高并发环境下的性能表现。 ...
狂神说JUC代码狂神说JUC代码
09-11
【狂神说JUC代码】是一系列专注于Java并发编程（JUC，Java Util Concurrency）的教程或笔记，旨在帮助开发者深入理解并掌握Java平台上的并发处理机制。JUC是Java标准库中的一组高级并发工具类，为多线程环境下的程序...
JUC多线程学习个人笔记
07-08
1. **线程池**：JUC通过Executor框架实现了线程池，允许开发者根据需求创建和管理线程。线程池可以减少线程创建和销毁的开销，提高系统的响应速度和资源利用率。线程池的核心组件包括ExecutorService、...
ConcurrentHashMap介绍
HFUTJungle的博客
07-22 2724
ConcurrentHashMap从JDK1.5开始随java.util.concurrent包一起引入JDK中，主要为了解决HashMap线程不安全和HashTable效率不高的问题。
java编发编程之：CuncurrentHashMap
weixin_34062329的博客
06-24 566
2019独角兽企业重金招聘Python工程师标准>>> ...
CuncurrentHashMap 1.8源码分析
jiangying257的博客
03-21 855
ConcurrentHashMap源码分析(二) 一、jdk1.8容器初始化 1、源码分析 在jdk8的ConcurrentHashMap中一共有5个构造方法，这四个构造方法中都没有对内部的数组做初始化， 只是对一些变量的初始值做了处理 jdk8的ConcurrentHashMap的数组初始化是在第一次添加元素时完成 //没有维护任何变量的操作，如果调用该方法，数组长度默认是16 public ConcurrentHashMap() { } //传递进来一个初始容量，ConcurrentHashMap
Map 综述（三）：彻头彻尾理解 ConcurrentHashMap
热门推荐
Rico's Blogs
05-27 13万+
ConcurrentHashMap是J.U.C的重要成员，它是HashMap的一个线程安全的版本。在默认理想状态下，ConcurrentHashMap可以支持16个线程执行并发写操作及任意数量线程的读操作。本文将结合Java内存模型和JDK源代码，剖析其高并发的具体实现机制，包括在JDK中的定义和结构、并发存取、重哈希和跨段操作，并着重剖析了ConcurrentHashMap读操作不需要加锁的内在奥秘和原理。
图形学知识点总结
weixin_40827685的博客
11-11 5557
计算机图形学基本概念，应用，前沿技术。 1. ISO 图形学的定义：应用计算机技术进行图形 的生成、处理和输出。 研究对象 —— 图形。 2.图形：是从客观世界物体中抽象出来的带有颜色及形状信息的图和形。 图形的构成要素： 几何要素：点、线、面、体等。 非几何要素：描述对象的颜色、材质等。 图形的表示方法：点阵法：枚举出图形中所有点；参数法：由图形的形状参数(方程表达式的系数，线段端点坐标)和属性参数（颜色）表示 3 图形与图像 图像image：由像素点组合而成。一般用二维矩阵...
Java ConcurrentHashMap深度解析：JDK1.7与JDK1.8的区别
本资料主要探讨了`ConcurrentHashMap`在JDK 1.7和1.8中的实现方式及其差异。 在JDK 1.7之前，`ConcurrentHashMap`采用了分段锁（Segment）的设计理念，将整个哈希表分割成多个独立的段，每个段拥有自己的锁。这样，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值