ConcurrentHashMap 源码分析03之内部类ForEachTask、SearchTask

最新推荐文章于 2023-12-30 10:45:00 发布
最新推荐文章于 2023-12-30 10:45:00 发布
阅读量339 收藏
点赞数 1
分类专栏： java 文章标签： java concurrentMap 源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44245828/article/details/110455133
版权

此处的内部类很多类似，这里只解释 ForEachEntryTask、ForEachTransformedEntryTask、SearchMappingsTask。

1.3.22 BulkTask

  • 处理批量任务，众多子类，基本上包含Task的内部类就是其子类
abstract static class BulkTask<K,V,R> extends CountedCompleter<R> {
    Node<K,V>[] tab;        // tab 数组
    Node<K,V> next;			// 下一节点
    /* stack: 栈顶结点， spare: 备用节点，相当于中继节点 */
    TableStack<K,V> stack, spare;
    int index; // 索引下标
    int baseIndex; // 上界
    int baseLimit; // 下界
    final int baseSize; // 个数
    int batch;              // 并行批量处理个数(但不等同于线程个数)
	/* 构造函数：指定各种属性值 */
    BulkTask(BulkTask<K,V,?> par, int b, int i, int f, Node<K,V>[] t) {
        super(par);
        this.batch = b;
        this.index = this.baseIndex = i;
        /* 不同情况指定不同上界 */
        if ((this.tab = t) == null)
            this.baseSize = this.baseLimit = 0;
        else if (par == null)
            this.baseSize = this.baseLimit = t.length;
        else {
            this.baseLimit = f;
            this.baseSize = par.baseSize;
        }
    }

    /* 获取下一元素，不存在则返回null */
    /* 这里如果遇到扩容，存储当前状态pushState(t, i, n)，等到扩容完成后，取出状态recoverState(n) */
    final Node<K,V> advance() {
        Node<K,V> e;
        /* 如果已经进入了一个非空的hash桶，直接尝试获取它的下一个节点 */
        if ((e = next) != null)
            e = e.next;
        for (;;) {
            Node<K,V>[] t; int i, n;  // must use locals in checks
            /* 下一节点不为 null，直接返回 */
            if (e != null)
                return next = e;
            /* 下界 >= 上界 || tab数组为空 || tab数组长度 <= 下界 || index < 0，没有新桶，返回 null  */    
            if (baseIndex >= baseLimit || (t = tab) == null ||
                (n = t.length) <= (i = index) || i < 0)
                return next = null;
            /* 桶位元素存在 && hash值 < 0，若此时为链表节点，e 已经赋值完毕 */    
            if ((e = tabAt(t, i)) != null && e.hash < 0) {
            	/* 是否为移动节点(正在扩容) */
                if (e instanceof ForwardingNode) {
                    tab = ((ForwardingNode<K,V>)e).nextTable;
                    e = null;
                    pushState(t, i, n); // 保存当前遍历状态
                    continue;
                }
                else if (e instanceof TreeBin)
                    e = ((TreeBin<K,V>)e).first; // 返回树的首节点
                else
                    e = null;
            }
            /* 弹出存储状态 */
            if (stack != null)
                recoverState(n);
            else if ((index = i + baseSize) >= n)
                index = ++baseIndex; // 这里的主要作用是 index++ 即指针往前移一位
        }
    }
	/* 保存当前遍历状态 */
    private void pushState(Node<K,V>[] t, int i, int n) {
        TableStack<K,V> s = spare;  // spare备用，减少 new 对象
        if (s != null)
            spare = s.next;
        else
            s = new TableStack<K,V>();
        s.tab = t;
        s.length = n;
        s.index = i;
        s.next = stack;
        stack = s;
    }

    /* 恢复存储时的状态 */
    private void recoverState(int n) {
        TableStack<K,V> s; int len;
        /* (index += (len = s.length)) >= n 这里的作用是 获取 tab[i+n] 位置的值 */
        while ((s = stack) != null && (index += (len = s.length)) >= n) {
        	/* 恢复成保存时的状态，以此循环尚未遍历的后序的值 */
        	/* 从这里可以看到，若添加在扩容前[index ~ len-1]后的值，可以遍历的到，但桶位之前的值不会遍历 */
            n = len;
            index = s.index;
            tab = s.tab;
            s.tab = null;
            /* stack 后移，存储spare备用 */
            TableStack<K,V> next = s.next;
            s.next = spare;
            stack = next;
            spare = s;
        }
        /* 获取完 stack 后，index指针后移 */
        if (s == null && (index += baseSize) >= n)
            index = ++baseIndex;
    }
}

1.3.23 ForEachKeyTask

  • 遍历 key 的任务
@SuppressWarnings("serial")
static final class ForEachKeyTask<K,V>
    extends BulkTask<K,V,Void> {
    final Consumer<? super K> action;
    ForEachKeyTask
        (BulkTask<K,V,?> p, int b, int i, int f, Node<K,V>[] t,
         Consumer<? super K> action) {
        super(p, b, i, f, t);
        this.action = action;
    }
    public final void compute() {
        final Consumer<? super K> action;
        if ((action = this.action) != null) {
            for (int i = baseIndex, f, h; batch > 0 &&
                     (h = ((f = baseLimit) + i) >>> 1) > i;) {
                addToPendingCount(1);
                new ForEachKeyTask<K,V>
                    (this, batch >>>= 1, baseLimit = h, f, tab,
                     action).fork();
            }
            for (Node<K,V> p; (p = advance()) != null;)
                action.accept(p.key);
            propagateCompletion();
        }
    }
}

1.3.24 ForEachValueTask

  • 遍历 value 的任务
@SuppressWarnings("serial")
static final class ForEachValueTask<K,V>
    extends BulkTask<K,V,Void> {
    final Consumer<? super V> action;
    ForEachValueTask
        (BulkTask<K,V,?> p, int b, int i, int f, Node<K,V>[] t,
         Consumer<? super V> action) {
        super(p, b, i, f, t);
        this.action = action;
    }
    public final void compute() {
        final Consumer<? super V> action;
        if ((action = this.action) != null) {
            for (int i = baseIndex, f, h; batch > 0 &&
                     (h = ((f = baseLimit) + i) >>> 1) > i;) {
                addToPendingCount(1);
                new ForEachValueTask<K,V>
                    (this, batch >>>= 1, baseLimit = h, f, tab,
                     action).fork();
            }
            for (Node<K,V> p; (p = advance()) != null;)
                action.accept(p.val);
            propagateCompletion();
        }
    }
}

1.3.25 ForEachEntryTask

  • 遍历 entry 的任务，继承 BulkTask
@SuppressWarnings("serial")
static final class ForEachEntryTask<K,V>
    extends BulkTask<K,V,Void> {
    final Consumer<? super Entry<K,V>> action; // 传入的 action 动作
    ForEachEntryTask
        (BulkTask<K,V,?> p, int b, int i, int f, Node<K,V>[] t,
         Consumer<? super Entry<K,V>> action) {
        super(p, b, i, f, t);
        this.action = action;
    }
    /* 执行遍历的真正的方法 */
    public final void compute() {
        final Consumer<? super Entry<K,V>> action;
        /* action 为 null 没必要进行操作 */
        if ((action = this.action) != null) {
        	/* 这里为循环分解任务，fork 为在池中添加任务 */
            for (int i = baseIndex, f, h; batch > 0 &&
                     (h = ((f = baseLimit) + i) >>> 1) > i;) {
                addToPendingCount(1); // 分任务 + 1
                new ForEachEntryTask<K,V>
                    (this, batch >>>= 1, baseLimit = h, f, tab,
                     action).fork();
            }
            /* 遍历本任务的含有的所有元素 */
            for (Node<K,V> p; (p = advance()) != null; )
                action.accept(p);
            propagateCompletion(); // 是否所有分任务都执行完成
        }
    }
}

1.3.26 ForEachMappingTask

    • 遍历 map 的任务
@SuppressWarnings("serial")
static final class ForEachMappingTask<K,V>
    extends BulkTask<K,V,Void> {
    final BiConsumer<? super K, ? super V> action;
    ForEachMappingTask
        (BulkTask<K,V,?> p, int b, int i, int f, Node<K,V>[] t,
         BiConsumer<? super K,? super V> action) {
        super(p, b, i, f, t);
        this.action = action;
    }
    public final void compute() {
        final BiConsumer<? super K, ? super V> action;
        if ((action = this.action) != null) {
            for (int i = baseIndex, f, h; batch > 0 &&
                     (h = ((f = baseLimit) + i) >>> 1) > i;) {
                addToPendingCount(1);
                new ForEachMappingTask<K,V>
                    (this, batch >>>= 1, baseLimit = h, f, tab,
                     action).fork();
            }
            for (Node<K,V> p; (p = advance()) != null; )
                action.accept(p.key, p.val);
            propagateCompletion();
        }
    }
}

1.3.27 ForEachTransformedKeyTask

  • 遍历 转换key 的任务，相当于对key做一定的更换，在执行 action 动作
@SuppressWarnings("serial")
static final class ForEachTransformedKeyTask<K,V,U>
    extends BulkTask<K,V,Void> {
    final Function<? super K, ? extends U> transformer;
    final Consumer<? super U> action;
    ForEachTransformedKeyTask
        (BulkTask<K,V,?> p, int b, int i, int f, Node<K,V>[] t,
         Function<? super K, ? extends U> transformer, Consumer<? super U> action) {
        super(p, b, i, f, t);
        this.transformer = transformer; this.action = action;
    }
    public final void compute() {
        final Function<? super K, ? extends U> transformer;
        final Consumer<? super U> action;
        if ((transformer = this.transformer) != null &&
            (action = this.action) != null) {
            for (int i = baseIndex, f, h; batch > 0 &&
                     (h = ((f = baseLimit) + i) >>> 1) > i;) {
                addToPendingCount(1);
                new ForEachTransformedKeyTask<K,V,U>
                    (this, batch >>>= 1, baseLimit = h, f, tab,
                     transformer, action).fork();
            }
            for (Node<K,V> p; (p = advance()) != null; ) {
                U u;
                if ((u = transformer.apply(p.key)) != null)
                    action.accept(u);
            }
            propagateCompletion();
        }
    }
}

1.3.28 ForEachTransformedValueTask

  • 遍历转换value的任务，相当于对value 做一定的更换，在执行 action 动作
@SuppressWarnings("serial")
static final class ForEachTransformedValueTask<K,V,U>
    extends BulkTask<K,V,Void> {
    final Function<? super V, ? extends U> transformer;
    final Consumer<? super U> action;
    ForEachTransformedValueTask
        (BulkTask<K,V,?> p, int b, int i, int f, Node<K,V>[] t,
         Function<? super V, ? extends U> transformer, Consumer<? super U> action) {
        super(p, b, i, f, t);
        this.transformer = transformer; this.action = action;
    }
    public final void compute() {
        final Function<? super V, ? extends U> transformer;
        final Consumer<? super U> action;
        if ((transformer = this.transformer) != null &&
            (action = this.action) != null) {
            for (int i = baseIndex, f, h; batch > 0 &&
                     (h = ((f = baseLimit) + i) >>> 1) > i;) {
                addToPendingCount(1);
                new ForEachTransformedValueTask<K,V,U>
                    (this, batch >>>= 1, baseLimit = h, f, tab,
                     transformer, action).fork();
            }
            for (Node<K,V> p; (p = advance()) != null; ) {
                U u;
                if ((u = transformer.apply(p.val)) != null)
                    action.accept(u);
            }
            propagateCompletion();
        }
    }
}

1.3.29 ForEachTransformedEntryTask

  • 遍历 转换entry 的任务，相当于对 entry 做一定的更换，在执行 action 动作
@SuppressWarnings("serial")
staticfinal class ForEachTransformedEntryTask<K,V,U>
    extends BulkTask<K,V,Void> {
    final Function<Map.Entry<K,V>, ? extends U> transformer;
    final Consumer<? super U> action;
    /* 构造函数：初始化属性 */
    ForEachTransformedEntryTask
        (BulkTask<K,V,?> p, int b, int i, int f, Node<K,V>[] t,
         Function<Map.Entry<K,V>, ? extends U> transformer, Consumer<? super U> action) {
        super(p, b, i, f, t);
        this.transformer = transformer; this.action = action;
    }
    /* 真正执行遍历的方法 */
    public final void compute() {
        final Function<Map.Entry<K,V>, ? extends U> transformer;
        final Consumer<? super U> action;
        /* 分解任务的方法 */
        if ((transformer = this.transformer) != null &&
            (action = this.action) != null) {
            for (int i = baseIndex, f, h; batch > 0 &&
                     (h = ((f = baseLimit) + i) >>> 1) > i;) {
                addToPendingCount(1); // 分任务 + 1
                new ForEachTransformedEntryTask<K,V,U>
                    (this, batch >>>= 1, baseLimit = h, f, tab,
                     transformer, action).fork();
            }
            /* 遍历所有本任务的元素，accept方法 接收的参数 u 为 transformer返回的对象 */
            for (Node<K,V> p; (p = advance()) != null; ) {
                U u;
                if ((u = transformer.apply(p)) != null)
                    action.accept(u);
            }
            propagateCompletion(); // 是否所有分任务都完成
        }
    }
}

1.3.30 ForEachTransformedMappingTask

  • 遍历 转换map元素 的任务，相当于对map元素做一定的更换，在执行 action 动作
@SuppressWarnings("serial")
static final class ForEachTransformedMappingTask<K,V,U>
    extends BulkTask<K,V,Void> {
    final BiFunction<? super K, ? super V, ? extends U> transformer;
    final Consumer<? super U> action;
    ForEachTransformedMappingTask
        (BulkTask<K,V,?> p, int b, int i, int f, Node<K,V>[] t,
         BiFunction<? super K, ? super V, ? extends U> transformer,
         Consumer<? super U> action) {
        super(p, b, i, f, t);
        this.transformer = transformer; this.action = action;
    }
    public final void compute() {
        final BiFunction<? super K, ? super V, ? extends U> transformer;
        final Consumer<? super U> action;
        if ((transformer = this.transformer) != null &&
            (action = this.action) != null) {
            for (int i = baseIndex, f, h; batch > 0 &&
                     (h = ((f = baseLimit) + i) >>> 1) > i;) {
                addToPendingCount(1);
                new ForEachTransformedMappingTask<K,V,U>
                    (this, batch >>>= 1, baseLimit = h, f, tab,
                     transformer, action).fork();
            }
            for (Node<K,V> p; (p = advance()) != null; ) {
                U u;
                if ((u = transformer.apply(p.key, p.val)) != null)
                    action.accept(u);
            }
            propagateCompletion();
        }
    }
}

1.3.31 SearchKeysTask

  • 查找 keys 的任务
@SuppressWarnings("serial")
static final class SearchKeysTask<K,V,U>
    extends BulkTask<K,V,U> {
    /* 查找方法 */
    final Function<? super K, ? extends U> searchFunction;
    final AtomicReference<U> result;
    SearchKeysTask
        (BulkTask<K,V,?> p, int b, int i, int f, Node<K,V>[] t,
         Function<? super K, ? extends U> searchFunction,
         AtomicReference<U> result) {
        super(p, b, i, f, t);
        this.searchFunction = searchFunction; this.result = result;
    }
    public final U getRawResult() { return result.get(); }
    public final void compute() {
        final Function<? super K, ? extends U> searchFunction;
        final AtomicReference<U> result;
        if ((searchFunction = this.searchFunction) != null &&
            (result = this.result) != null) {
            for (int i = baseIndex, f, h; batch > 0 &&
                     (h = ((f = baseLimit) + i) >>> 1) > i;) {
                if (result.get() != null)
                    return;
                addToPendingCount(1);
                new SearchKeysTask<K,V,U>
                    (this, batch >>>= 1, baseLimit = h, f, tab,
                     searchFunction, result).fork();
            }
            while (result.get() == null) {
                U u;
                Node<K,V> p;
                if ((p = advance()) == null) {
                    propagateCompletion();
                    break;
                }
                if ((u = searchFunction.apply(p.key)) != null) {
                    if (result.compareAndSet(null, u))
                        quietlyCompleteRoot();
                    break;
                }
            }
        }
    }
}

1.3.32 SearchValuesTask

    • 查找 values的任务
@SuppressWarnings("serial")
static final class SearchValuesTask<K,V,U>
    extends BulkTask<K,V,U> {
    final Function<? super V, ? extends U> searchFunction;
    final AtomicReference<U> result;
    SearchValuesTask
        (BulkTask<K,V,?> p, int b, int i, int f, Node<K,V>[] t,
         Function<? super V, ? extends U> searchFunction,
         AtomicReference<U> result) {
        super(p, b, i, f, t);
        this.searchFunction = searchFunction; this.result = result;
    }
    public final U getRawResult() { return result.get(); }
    public final void compute() {
        final Function<? super V, ? extends U> searchFunction;
        final AtomicReference<U> result;
        if ((searchFunction = this.searchFunction) != null &&
            (result = this.result) != null) {
            for (int i = baseIndex, f, h; batch > 0 &&
                     (h = ((f = baseLimit) + i) >>> 1) > i;) {
                if (result.get() != null)
                    return;
                addToPendingCount(1);
                new SearchValuesTask<K,V,U>
                    (this, batch >>>= 1, baseLimit = h, f, tab,
                     searchFunction, result).fork();
            }
            while (result.get() == null) {
                U u;
                Node<K,V> p;
                if ((p = advance()) == null) {
                    propagateCompletion();
                    break;
                }
                if ((u = searchFunction.apply(p.val)) != null) {
                    if (result.compareAndSet(null, u))
                        quietlyCompleteRoot();
                    break;
                }
            }
        }
    }
}

1.3.33 SearchEntriesTask

  • 查找 entries 的任务
@SuppressWarnings("serial")
static final class SearchEntriesTask<K,V,U>
    extends BulkTask<K,V,U> {
    final Function<Entry<K,V>, ? extends U> searchFunction;
    final AtomicReference<U> result;
    SearchEntriesTask
        (BulkTask<K,V,?> p, int b, int i, int f, Node<K,V>[] t,
         Function<Entry<K,V>, ? extends U> searchFunction,
         AtomicReference<U> result) {
        super(p, b, i, f, t);
        this.searchFunction = searchFunction; this.result = result;
    }
    public final U getRawResult() { return result.get(); }
    public final void compute() {
        final Function<Entry<K,V>, ? extends U> searchFunction;
        final AtomicReference<U> result;
        if ((searchFunction = this.searchFunction) != null &&
            (result = this.result) != null) {
            for (int i = baseIndex, f, h; batch > 0 &&
                     (h = ((f = baseLimit) + i) >>> 1) > i;) {
                if (result.get() != null)
                    return;
                addToPendingCount(1);
                new SearchEntriesTask<K,V,U>
                    (this, batch >>>= 1, baseLimit = h, f, tab,
                     searchFunction, result).fork();
            }
            while (result.get() == null) {
                U u;
                Node<K,V> p;
                if ((p = advance()) == null) {
                    propagateCompletion();
                    break;
                }
                if ((u = searchFunction.apply(p)) != null) {
                    if (result.compareAndSet(null, u))
                        quietlyCompleteRoot();
                    return;
                }
            }
        }
    }
}

1.3.34 SearchMappingsTask

    • 查找 mappings 的任务
@SuppressWarnings("serial")
static final class SearchMappingsTask<K,V,U>
    extends BulkTask<K,V,U> {
    final BiFunction<? super K, ? super V, ? extends U> searchFunction;
    final AtomicReference<U> result;
    /* 构造函数：初始化属性值 */
    SearchMappingsTask
        (BulkTask<K,V,?> p, int b, int i, int f, Node<K,V>[] t,
         BiFunction<? super K, ? super V, ? extends U> searchFunction,
         AtomicReference<U> result) {
        super(p, b, i, f, t);
        this.searchFunction = searchFunction; this.result = result;
    }
    /* 获取结果值 */
    public final U getRawResult() { return result.get(); }
    /* 分解并遍历元素的方法 */
    public final void compute() {
        final BiFunction<? super K, ? super V, ? extends U> searchFunction;
        final AtomicReference<U> result;
        /* searchFunction || result 为null 则没必要继续 */
        if ((searchFunction = this.searchFunction) != null &&
            (result = this.result) != null) {
            for (int i = baseIndex, f, h; batch > 0 &&
                     (h = ((f = baseLimit) + i) >>> 1) > i;) {
                /* 已有结果，直接返回 */     
                if (result.get() != null)
                    return;
                addToPendingCount(1); // 分任务 + 1
                new SearchMappingsTask<K,V,U>
                    (this, batch >>>= 1, baseLimit = h, f, tab,
                     searchFunction, result).fork();
            }
            /* 结果为null则循环遍历当前任务的所有元素 */
            while (result.get() == null) {
                U u;
                Node<K,V> p;
                /* 当前任务所有元素遍历完成 */
                if ((p = advance()) == null) {
                    propagateCompletion(); // 查看其他分任务是否成功完成任务
                    break;
                }
                /* 找到符合的元素 */
                if ((u = searchFunction.apply(p.key, p.val)) != null) {
                	/* CAS 设置 result */
                    if (result.compareAndSet(null, u))
                        quietlyCompleteRoot(); // 盲猜应该是设置查找任务完成
                    break;
                }
            }
        }
    }
}
cerish404
关注
专栏目录
ConcurrentHashMap 源码分析08函数篇之 forEach、 search详解
weixin_44245828的博客
12-09 2168
1. forEach(BiConsumer<? super K, ? super V> action) 使用 Traverser 类的 advance 方法获取下一元素，遍历直至获取到 null public void forEach(BiConsumer<? super K, ? super V> action) { if(action == null) throw new NullPointerException(); Node<K,V>[] t;
javacurrentmap_Java ConcurrentHashMap.forEach方法代码示例
weixin_31221157的博客
12-23 372
import java.util.concurrent.ConcurrentHashMap; //导入方法依赖的package包/类public static void main(String[] args) {ConcurrentHashMap> userHash = new ConcurrentHashMap<>();HashFiller hashFiller = new H...
ConcurrentHashMap 源码分析04之内部类ReduceTask
weixin_44245828的博客
12-02 280
1.3.35 ReduceKeysTask @SuppressWarnings("serial") static final class ReduceKeysTask<K,V> extends BulkTask<K,V,K> { final BiFunction<? super K, ? super K, ? extends K> reducer; K result; ReduceKeysTask<K,V> rights, ne
java编程ConcurrentHashMap详解
最新发布
技术研究中心
12-30 949
ConcurrentHashMap是Java中的一个并发容器，它是HashMap的线程安全版本，专为多线程并发访问而设计。与HashMap不同的是，ConcurrentHashMap提供了更高效的并发性能，减小了在多线程环境下出现的竞态条件。通过本文对ConcurrentHashMap的详细解析，我们深入了解了其基本用法、工作原理以及性能优化方法。ConcurrentHashMap作为Java编程中常用的并发容器，为我们提供了高效的并发读写功能，广泛应用于多线程编程的各个领域。
ConcurrentHashMap详解
Black的博客
08-22 454
ConcurrentHashMap详解
Java并发系列之ConcurrentHashMap源码分析
08-27
Java并发系列之ConcurrentHashMap源码分析 ConcurrentHashMap是Java中一个高性能的哈希表实现，它解决了HashTable的同步问题，允许多线程同时操作哈希表，从而提高性能。 1. ConcurrentHashMap的成员变量： ...
ConcurrentHashMap源码分析源码分析
04-12
ConcurrentHashMap源码分析源码分析 代码解释非常详细！！！！
第二章 ConcurrentHashMap源码分析（JDK8版本）1
08-04
- `Node`: `Node`是`ConcurrentHashMap`的核心内部类，它包含了键值对。与`HashMap`中的`Node`类似，但`Node`在JDK8中对`value`和`next`字段使用了`volatile`关键字，确保多线程环境下的可见性。`Node`不提供直接...
多线程(十)： 并发中集合ConcurrentHashMap
人不风流枉少年
09-01 4381
public class HashTest { static Map&amp;amp;amp;amp;amp;amp;lt;String, String&amp;amp;amp;amp;amp;amp;gt; map = new HashMap&amp;amp;amp;amp;amp;amp;lt;&amp;amp;amp;amp;amp;amp;gt;(); public static void main(String[] args) {
Java8-ConcurrentHashMap
weixin_33832340的博客
12-16 70
import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ForkJoinPool; public class ConcurrentHashMap1 { public static void main(String[] args) { ...
Java8下的ConcurrentHashMap新操作
ZERO
05-05 7188
更新值        在Java7时，对ConcurrentHashMap进行线程安全的更新操作需要使用循环来处理（可以参见http://blog.csdn.net/zero__007/article/details/49833819），但是在Java8中提供了更方便的原子更新方法。 public V compute(K key, BiFunction remappingFunction)
JDK1.8源码学习之ConcurrentHashMap.java
journey_fan的专栏
04-22 2122
jdk1.8源码学习之并发HashMap————ConcurrentHashMap.java package java.util.concurrent; import java.io.ObjectStreamField; import java.io.Serializable; import java.lang.reflect.ParameterizedType; import java.la
ConCurrentHashMap
csdnnmbdybb的博客
12-05 1117
1. 那么ConcurrentHashMap是如何判断在统计的时候容器是否发生了变化呢?使用modCount变量,在put、 remove 和clean 方法里操作元素前都会将变量modCount进行加1，那么在统计size前后比较modCount是否发生变化，从而得知容器的大小 是否发生变化。 2. 关于该类中一些方法的测试： parallelismThreshold参数,如果map的siz...
Java并发（二）：并发容器之ConcurrentHashMap
天涯明月
03-01 178
ConcurrentHashMap 　　本来是想以JDK1.8为例的，只是后来发现源码用的是1.7的，所以这里就干脆以1.7进行说明吧，关于ConcurrentHashMap1.8中大体功能没变，主要是加了红黑树结构的转换功能。 　　1.7中ConcurrentHashMap包含一个Segment[]数组（默认大小16），Segment和HashHap的结构类似，内部包含一个HashEntry&...
ConcurrentHashMap让你的代码飞起来【Java多线程必备】
Mr.绵羊的知识星球
05-02 2479
1. ConcurrentHashMap介绍特性和使用 2. 实际使用案例 3. 和HashMap简单对比
ConcurrentHashMap篇一
学无止境~贵在坚持~
03-30 698
例如,在计算共享注册表中的值的快照摘要时.有三种操作,每种操作有四种形式,接受带有Keys,Values, Entries和(Key, Value)参数的函数.因为ConcurrentHashMap的元素没有以任何特定的方式排序,并且可以在不同的并行执行中以不同的顺序进行处理,所以提供的函数的正确性不应该取决于任何排序,或者在计算过程中可能暂时改变的任何其他对象或值;(在键值能否为空上)与Hashtable相同,但和HashMap不同的是ConcurrentHashMap键和值都不能为空。
java concurrentmap遍历_Java中遍历ConcurrentHashMap的四种方式
weixin_42490307的博客
02-12 1491
//方式一：在for-each循环中使用entries来遍历System.out.println("方式一：在for-each循环中使用entries来遍历");for(Map.Entry entry: map.entrySet()) {System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());}...
Windows Phone开发（26）：启动器与选择器之MediaPlayerLauncher和SearchTask
mmdev
03-29 114
启动器与选择器简单的地方在于，它们的使用方法几乎一模一样，从前面几节中，我相信大家基本上都知道如何使用它们了。 这里还是哆嗦一下吧，使用启动器和选择器的步骤如下： 1、实例化，new一个； 2、准备各参数，对相关的属性赋值； 3、Show； 4、对于启动器，不需要这步，但选择器有返回数据，所以需要处理完成事件。 本节再举两例子，启动器和选择器就可以完成了，然后我们下一节开始，探讨新的知...
ConcurrentHashMap 源码分析
08-11
ConcurrentHashMap是Java中的一个并发容器，用于在多线程环境中安全地存储和访问键值对。它使用了一些特殊的技术来提高其并发性能。 ConcurrentHashMap的源码分析可以从几个关键点开始。首先，它使用了大量的CAS（Compare and Swap）操作来代替传统的重量级锁操作，从而提高了并发性能。只有在节点实际变动的过程中才会进行加锁操作，这样可以减少对整个容器的锁竞争。 其次，ConcurrentHashMap的数据结构是由多个Segment组成的，每个Segment又包含多个HashEntry。这样的设计使得在多线程环境下，不同的线程可以同时对不同的Segment进行操作，从而提高了并发性能。每个Segment都相当于一个独立的HashMap，有自己的锁来保证线程安全。 在JDK1.7版本中，ConcurrentHashMap采用了分段锁的设计，即每个Segment都有自己的锁。这样的设计可以在多线程环境下提供更好的并发性能，因为不同的线程可以同时对不同的Segment进行读写操作，从而减少了锁竞争。 总的来说，ConcurrentHashMap通过使用CAS操作、分段锁以及特定的数据结构来实现线程安全的并发访问。这使得它成为在多线程环境中高效地存储和访问键值对的选择。123 #### 引用[.reference_title] - *1* [ConcurrentHashMap 源码解析](https://blog.csdn.net/Vampirelzl/article/details/126548972)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT0_1"}} ] [.reference_item] - *2* *3* [ConcurrentHashMap源码分析](https://blog.csdn.net/java123456111/article/details/124883950)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT0_1"}} ] [.reference_item] [ .reference_list ]
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值