Java并发性AtomicLongArray类

java.util.concurrent.atomic.AtomicLongArray类提供对基础长数组的操作，该数组可以以原子方式读取和写入，并且还包含高级原子操作。AtomicLongArray支持基础长数组变量的原子操作。它具有读取和写入易失性变量的方法。也就是说，一个集合与之后的任何一个变量之间都有一个前后关系。原子compareAndSet方法也具有这些内存一致性功能。

AtomicLongArray方法

以下是AtomicLongArray类中可用的重要方法列表。

Sr.No.	方法和描述
1	public long addAndGet（int i，long delta）以原子方式将给定值添加到索引i处的元素。
2	public boolean compareAndSet(int i, long expect, long update) 如果当前值==期望值，则以原子方式将位置i上的元素设置为给定的更新值。
3	public long decrementAndGet（int i）原子减少一个索引为i的元素。
4	public long get（int i）获取位置i处的当前值。
5	public long getAndAdd（int i，long delta）以原子方式将给定值添加到索引i处的元素。
6	public long getAndDecrement（int i）原子减少一个索引为i的元素。
7	public long getAndIncrement（int i）原子指数i增加了一个元素。
8	public long getAndSet（int i，long newValue）以原子方式将位置i处的元素设置为给定值并返回旧值。
9	public long incrementAndGet（int i）原子指数i增加了一个元素。
10	public void lazySet（int i，long newValue）最终将位置i处的元素设置为给定值。
11	public int length（）返回数组的长度。
12	public void set（int i，long newValue）将位置i处的元素设置为给定值。
13	public String toString（）返回数组当前值的字符串表示形式。
14	public boolean weakCompareAndSet（int i，long expect，long update）如果当前值==期望值，则以原子方式将位置i上的元素设置为给定的更新值。

例

以下TestThread程序在基于线程的环境中显示AtomicIntegerArray变量的用法。

import java.util.concurrent.atomic.AtomicLongArray;

public class TestThread {
   private static AtomicLongArray atomicLongArray = new AtomicLongArray(10);

   public static void main(final String[] arguments) throws InterruptedException {

      for (int i = 0; i<atomicLongArray.length(); i++) {
         atomicLongArray.set(i, 1);
      }

      Thread t1 = new Thread(new Increment());
      Thread t2 = new Thread(new Compare());
      t1.start();
      t2.start();

      t1.join();
      t2.join();

      System.out.println("Values: ");

      for (int i = 0; i<atomicLongArray.length(); i++) {
         System.out.print(atomicLongArray.get(i) + " ");
      }
   }  

   static class Increment implements Runnable {

      public void run() {

         for(int i = 0; i<atomicLongArray.length(); i++) {
            long add = atomicLongArray.incrementAndGet(i);
            System.out.println("Thread " + Thread.currentThread().getId()
               + ", index " +i + ", value: "+ add);
         }
      }
   }

   static class Compare implements Runnable {

      public void run() {

         for(int i = 0; i<atomicLongArray.length(); i++) {
            boolean swapped = atomicLongArray.compareAndSet(i, 2, 3);

            if(swapped) {
               System.out.println("Thread " + Thread.currentThread().getId()
                  + ", index " +i + ", value: 3");
            }
         }
      }
   }
}

这将产生以下结果。

输出

Thread 9, index 0, value: 2
Thread 10, index 0, value: 3
Thread 9, index 1, value: 2
Thread 9, index 2, value: 2
Thread 9, index 3, value: 2
Thread 9, index 4, value: 2
Thread 10, index 1, value: 3
Thread 9, index 5, value: 2
Thread 10, index 2, value: 3
Thread 9, index 6, value: 2
Thread 10, index 3, value: 3
Thread 9, index 7, value: 2
Thread 10, index 4, value: 3
Thread 9, index 8, value: 2
Thread 9, index 9, value: 2
Thread 10, index 5, value: 3
Thread 10, index 6, value: 3
Thread 10, index 7, value: 3
Thread 10, index 8, value: 3
Thread 10, index 9, value: 3
Values:
3 3 3 3 3 3 3 3 3 3