在循环中避免使用AtomicInteger Java [关闭]

Question

关闭。这个问题需要details or clarity。它当前不接受答案。

---

是否要改善此问题？通过editing this post添加详细信息并澄清问题。

关闭[22小时前。

我希望使用parallelStream读取/写入一个数组（并更新另一个数组），但没有索引。

[AtomicInteger不允许按位运算，并且使用j.get() * 2的速度很慢：

final int[] j = {0};
ps.parallelStream().forEach(p -> {
    long k = next[j[0] << 1];                       
    for(; k < finalK; k += p)
        seg[(int) (k >>> S)] |= (1L << (k & BMASK));
    next[j[0] << 1] = (k - finalK);

    k = next[j[0] << 1 | 1];                        
    for(; k < finalK; k+= p) 
        seg[(int) (k >>> S)] |= (1L << (k & BMASK));
    next[j[0] << 1 | 1] = (k - finalK);
    j[0]++;
});

这是在顺序流中工作，而不是并行。

[抱歉，如果seg[(int) (k >>> S)] |= (1L << (k & BMASK));似乎不可读，这与设置BitSet的bit k相同（seg是long []），对于我的目的，这太慢了。

Answer 1

使用丑陋的ConcurrentHashMap<Long, Long[]>解决，避免使用奇数\偶数索引

next.replaceAll((p, k)->{

    for(; k[0] < finalK; k[0] += p)
        seg[(int) (k[0] >>> S)] |= (1L << (k[0] & BMASK));

    for(; k[1] < finalK; k[1] += p)                         
        seg[(int) (k[1] >>> S)] |= (1L << (k[1] & BMASK));

    return new long[]{k[0]-finalK, k[1]-finalK});
});

但是这很慢，并且使用更多的内存

编辑我使用了一个小indexPairs类而不是数组

来改进了东西

ConcurrentHashMap<Long, indexPairs> next = initNext();
while(condition) {
    next.replaceAll((p, k) -> {
        for (; k.low < finalK; k.low += p)
            seg[(int) (k.low >>> S)] |= (1L << (k.low & BMASK));
        k.low -= finalK;
        for (; k.high < finalK; k.high += p)                 
            seg[(int) (k.high >>> S)] |= (1L << (k.high & BMASK));
        k.high -= finalK;
        return k;
    });
    ... Do something with seg
}