java Atomic 数组类

朴灿烈づ我的快乐病毒、 2022-11-21 14:42 173阅读 0赞

# 前言 #

我们看下`Atomic`对于数组类的封装

1.  `AtomicIntegerArray`
2.  `AtomicLongArray`
3.  `AtomicReferenceArray`

我们这里以`AtomicLongArray` 来做说明。

为什么需要退出数组类别的原子操作类？

1.  可见性问题
2.  原子性操作问题

此类问题可以查看博主另一篇文章: [java Atomic 基本数据类型  
][java Atomic _]

# 函数说明 #

`AtomicLongArray` 类方法如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70_pic_center]

1.  `length()`  
    数组长度
2.  `get(int i)`  
    具有`volatile`读特性方式读取数组下标指定的位置。（`可见性`和`Happe-Before`）
3.  `set(int i, long newValue)`  
    具有`volatile`读特性方式设置数组下标对应的数值。（`可见性`和`Happe-Before`）
4.  `lazySet(int i, long newValue)`  
    完全等价`set(int i, long newValue)`，并无懒加载等.
5.  `getAndSet(int i, long newValue)`  
    返回数组i位置的数值，然后设置一个新的数值为`newValue`
6.  `compareAndSet(int i, long expect, long update)`  
    如果下标i位置的数值等于`expect`,那么将下标位置的数值更新为`update`,如果成功返回true。
7.  `weakCompareAndSet(int i, long expect, long update)`  
    完全等价`compareAndSet`
8.  `getAndIncrement(int i)`  
    得到下标i的数值，然后对这个下标数值自增1
9.  `getAndDecrement(i)`  
    得到下标i的数值，然后对这个下标数值自减1
10. `getAndAdd(int i, long delta)`  
    返回下标i的数值，然后和`delta`相加放回数组
11. `incrementAndGet(int i)`  
    自增数组下标为i的数值，然后返回自增后的数值
12. `decrementAndGet(int i)`  
    自减数组下标为i的数值，然后返回自减后的数值
13. `addAndGet(int i, long delta)`  
    数组下标为i数值加`delta`,返回加和后的数值
14. `getAndUpdate(int i, LongUnaryOperator updateFunction)`  
    对数组下标为i的位置设置数值为LongUnaryOperator返回的大小，然后返回之前的数值。

public static void main(String[] args) throws InterruptedException {
        
    
            long originLongArray[] = new long[10];
    
            AtomicLongArray atomicLongArray = new AtomicLongArray(originLongArray);
    
            long preData = atomicLongArray.getAndUpdate(1, new LongUnaryOperator() {
        
                @Override
                public long applyAsLong(long oldData) {
        
                    //旧数据加1
                    return oldData + 1;
                }
            });
    
            //输出0
            System.out.println(preData);
            //输出1
            System.out.println(atomicLongArray.get(1));
    
        }

1.  `updateAndGet(int i, LongUnaryOperator updateFunction)`  
    基本和`getAndUpdate(int i, LongUnaryOperator updateFunction)`类似，只不过返回数值为加和后的。
2.  `getAndAccumulate(int i, long x, LongBinaryOperator accumulatorFunction)`  
    对数组下标为i的位置设置数值为LongBinaryOperator返回的大小，然后返回之前的数值。

public static void main(String[] args) throws InterruptedException {
        
    
            long originLongArray[] = new long[10];
    
            AtomicLongArray atomicLongArray = new AtomicLongArray(originLongArray);
    
            long preData = atomicLongArray.getAndAccumulate(1, 20, new LongBinaryOperator() {
        
                @Override
                public long applyAsLong(long left, long right) {
        
                    //left 为0,也就是原始数组的数值
                    //right 20，传入的数值
                    return left+right;
                }
            });
    
            //输出0
            System.out.println(preData);
            //输出20
            System.out.println(atomicLongArray.get(1));
    
        }

1.  `accumulateAndGet(int i, long x, LongBinaryOperator accumulatorFunction)`
    
    和`getAndAccumulate(...)`类似，区别在于返回值为加和后的数值

## 可见性问题 ##

`AtomicLongArray`的实现中，会将传入的字符串做一次拷贝。

class AtomicLongArray{
        
     private final long[] array;
     public AtomicLongArray(long[] array) {
        
            // Visibility guaranteed by final field guarantees
            this.array = array.clone();
        }
    }

我们看到拷贝的字符串是一个非volatile修饰的数组，这样是否会带来可见性问题？如果正常直接从这个数组读取存储，答案是当然会引起可见性问题。  
然而`AtomicLongArray`读取和设置都采用`unsafe`提供函数，让其实现volatile的内存语义。

如下代码：

class AtomicLongArray{
        
    
     public final void set(int i, long newValue) {
        
     		//让这个元素具有volatile语义的方式存储到数组中，其他线程可以直接看到结果
            unsafe.putLongVolatile(array, checkedByteOffset(i), newValue);
        }
    
     public final long get(int i) {
        
            return getRaw(checkedByteOffset(i));
        }
    
        private long getRaw(long offset) {
        
        	//读取某个元素让其直接具有volatile读取的效果，可以直接读取到内存最新值
            return unsafe.getLongVolatile(array, offset);
        }
    }

[java Atomic _]: https://fanmingyi.blog.csdn.net/article/details/109409637
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/eff7a97fea37406681172c446a14328a.png