关于无锁的线程安全的整数，有以下三种

  • AtomicInteger
  • AtomicLong
  • LongAdder

AtomicInteger

示例

  1. import java.util.concurrent.*;
  2. import java.util.concurrent.atomic.*;
  4. public class AtomicClass {
  5.     public static AtomicInteger counter = new AtomicInteger();
  6.     public static Integer counter2 = 0;
  7.     public static Object mutex = new Object();
  8.     public static boolean useLock = false;
  10.     public static void main(String[] args) throws InterruptedException {
  11.         final Integer Thread_Amount = 20;
  13.         //1.创建线程池
  14.         ThreadPoolExecutor te = new ThreadPoolExecutor(Thread_Amount,Thread_Amount,0L,TimeUnit.SECONDS,
  15.                 new LinkedBlockingDeque<>());
  16.         //2.创建线程任务
  17.         Callable<Long> task = () -> {
  18.             long start = System.currentTimeMillis();
  19.             if(useLock == false){
  20.                 for(int k=0; k<100000; k++)
  21.                     counter.incrementAndGet();
  22.             }else{
  23.                 for(int k=0; k<100000; k++)
  24.                     synchronized (mutex){
  25.                         ++counter2;
  26.                     }
  27.             }
  28.             long end = System.currentTimeMillis();
  29.             return end - start;
  30.         };
  31.         // 在并发环境下CAS
  32.         useLock = false;
  33.         {
  34.             //3.创建线程
  35.             Future<Long>[] futures = new Future[Thread_Amount];
  36.             for(int i=0 ; i<Thread_Amount ; i++){
  37.                 futures[i] = te.submit(task);
  38.             }
  39.             //4.获得线程结果
  40.             long totaltime = 0;
  41.             try {
  42.                 for(int i=0 ; i<Thread_Amount ; i++)
  43.                     totaltime += futures[i].get();
  44.             } catch (ExecutionException e) {
  45.                 e.printStackTrace();
  46.             }
  47.             //5.打印结果
  48.             System.out.println("当不使用锁时花费时间:" + totaltime + "ms");
  49.         }
  50.         // 在并发环境下使用锁
  51.         useLock = true;
  52.         {
  53.             //3.创建线程
  54.             Future<Long>[] futures = new Future[Thread_Amount];
  55.             for(int i=0 ; i<Thread_Amount ; i++){
  56.                 futures[i] = te.submit(task);
  57.             }
  58.             //4.获得线程结果
  59.             long totaltime = 0;
  60.             try {
  61.                 for(int i=0 ; i<Thread_Amount ; i++)
  62.                     totaltime += futures[i].get();
  63.             } catch (ExecutionException e) {
  64.                 e.printStackTrace();
  65.             }
  66.             //5.打印结果
  67.             System.out.println("当使用锁时花费时间:" + totaltime + "ms");
  68.         }
  70.         //7.关闭线程池
  71.         te.shutdown();
  72.     }
  73. }

console

  1. 当不使用锁时花费时间:413ms
  2. 当使用锁时花费时间:2168ms

将Thread_Amount改为50后的控制台输出：

  1. 当不使用锁时花费时间:723ms
  2. 当使用锁时花费时间:12023ms

可以看出，CAS的性能远高于锁，而且，随着线程数的增加，其性能差距会变得更大。

AtomicLong 与 LongAdder

其中LongAdder是jdk引进的，其性能远高于AtomicLong.

LongAdder的优化：

  • 热点数据的分离(将对一个被频繁访问的数据的操作变成对一个数组的操作，再对数组求和得到应有的数据)
  • 避免了伪共享(避免因其他变量修改而重新加载)

下面的代码可能涉及到高并发模型Future，详见笔记 链接

示例

  1. import java.util.concurrent.*;
  2. import java.util.concurrent.atomic.AtomicLong;
  3. import java.util.concurrent.atomic.LongAdder;
  5. //改注解可以解决伪共享问题
  6. //@sun.misc.Contended
  7. public class LongAdderTest {
  9.     static class MyTask implements Callable<Long> {
  10.         private static Object mutex = new Object();
  11.         private static Long counter = 0L;
  12.         private static AtomicLong aCounter = new AtomicLong(0);
  13.         private static LongAdder lCounter = new LongAdder();
  14.         /**
  15.          * state = 0，使用锁进行Long类型的共享
  16.          * state = 1，使用AtomicLong
  17.          * state = 2， 使用LongAdder
  18.          */
  19.         private int state = 0;
  20.         private static int LIMIT = 10000000;
  21.         public MyTask(int state) {
  22.             this.state = state;
  23.         }
  24.         @Override
  25.         public Long call() {
  26.             long b = 0, e = 0;
  27.             if(state == 0){
  28.                 b = System.currentTimeMillis();
  29.                 for(int i=0 ; i<LIMIT ; i++){
  30.                     synchronized (mutex){
  31.                         ++counter;
  32.                     }
  33.                 }
  34.                 e = System.currentTimeMillis();
  36.             }else if(state == 1){
  37.                 b = System.currentTimeMillis();
  38.                 for(int i=0 ; i<LIMIT ; i++){
  39.                     aCounter.incrementAndGet();
  40.                 }
  41.                 e = System.currentTimeMillis();
  43.             }else if(state == 2){
  44.                 b = System.currentTimeMillis();
  45.                 for(int i=0 ; i<LIMIT ; i++){
  46.                     lCounter.increment();
  47.                 }
  48.                 e = System.currentTimeMillis();
  49.             }
  50.             return e - b;
  51.         }
  52.     }
  54.     public static void main(String[] args) throws ExecutionException, InterruptedException {
  55.         ExecutorService ep = Executors.newFixedThreadPool(12);
  57.         Future<Long>[] futures = new Future[4];
  58.         for(int i=0 ; i<4 ; i++){
  59.             futures[i] = ep.submit(new MyTask(0));
  60.         }
  62.         Future<Long>[] futures2 = new Future[4];
  63.         for(int i=0 ; i<4 ; i++){
  64.             futures2[i] = ep.submit(new MyTask(1));
  65.         }
  67.         Future<Long>[] futures3 = new Future[4];
  68.         for(int i=0 ; i<4 ; i++){
  69.             futures3[i] = ep.submit(new MyTask(2));
  70.         }
  72.         long time = 0;
  73.         for(Future<Long> future : futures){
  74.             time += future.get();
  75.         }
  76.         System.out.println("Long类型花费时间：" + time + "ms");
  78.         time = 0;
  79.         for(Future<Long> future : futures2){
  80.             time += future.get();
  81.         }
  82.         System.out.println("AtomicLong类型花费时间：" + time + "ms");
  84.         time = 0;
  85.         for(Future<Long> future : futures3){
  86.             time += future.get();
  87.         }
  88.         System.out.println("LongAdder类型花费时间：" + time + "ms");
  89.         ep.shutdown();
  90.     }
  91. }

console

  1. Long类型花费时间：10079ms
  2. AtomicLong类型花费时间：3597ms
  3. LongAdder类型花费时间：1278ms