Java多线程基础总结五：atomic

Java多线程基础总结五：atomic2012-06-23 iteye ftj20003在简单介绍java.util.concurrent.atomic包之前，有个概念要先抄袭熟悉一遍：CAS（比较并交换）。现在大多数的处理器都提供对并发访问的支持，这个支持的反映方式就是提供硬件的指令支持多处理的特殊需求。比如检测或者阻止其它处理器的并发访问来更新共享变量的指令。对于 Intel x86架构的处理器来说就是通过提供实现CAS或者比较并设置的硬件原语指令集。CAS操作的三个操作数：内存位置（V），预期原值（A）和新值（B）。执行的过程通常是：预测内存地址V应该包含值A，如果包含则将值B替换到位置V；否则，不更改任何值，告知地址V的当前值。CAS对待“读－修改－写”的操作一般是检测这个过程是否有其它的线程在修改变量，如果有那么这次的CAS操作失败，可以尝试重新进行CAS。讲到这里似乎感觉比 Synchronized还复杂，是否意味着成本不小呢？答案是否。因为它是硬件原生实现的，极为轻量级的无锁同步方式。就好像高清解码一样，GPU原生硬件解码比软解的CPU占用优势那是相当的不一样啊！

说到硬件我就想到最近狂能争论的使用64位操作系统的优势。现在处理器多数支持64位，意味着处理器的寄存器映射到内存的寻址空间大大的大了，操作系统 64位的架构或许在内存管理上的挑战更大了，没有好的内存压缩技术，大内存只能是大浪费。同时还表示如果三方软件开发者对64位系统内存管理不熟悉，软件变垃圾的概率变大了。没有好的64位三方软件的繁荣，操作系统仅仅作为一个支撑软件运行的平台能干什么呢？所以使用优势不在操作系统本身而在于平台之上的软件。又扯远了，哎...

JDK5以后在java.util.concurrent.atomic包下提供了十几个原子类。常见的是 AtomicInteger,AtomicLong,AtomicReference以及它们的数组形式，还有AtomicBoolean和为了处理 ABA问题引入的AtomicStampedReference类，最后就是基于反射的对volatile变量进行更新的实用工具类：AtomicIntegerFieldUpdater,AtomicLongFieldUpdater,AtomicReferenceFieldUpdater。这些原子类理论上能够大幅的提升性能。并且java.util.concurrent内的并发集合，线程池，执行器，同步器的内部实现大量的依赖这些无锁原子类，从而争取性能的最大化。下面通过一个简单的例子看看：

Java代码

import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
import java.util.concurrent.atomic.AtomicInteger;

/**
  * User: yanxuxin
  * Date: Dec 16, 2009
  * Time: 10:49:40 PM
  */
public class AtomicCounterSample extends Thread {
   private AtomicCounter atomicCounter;

   public AtomicCounterSample（AtomicCounter atomicCounter） {
     this.atomicCounter = atomicCounter;
   }

   @Override 
   public void run（） {
     long sleepTime = （long） （Math.random（） * 100）;
     try {
       Thread.sleep（sleepTime）;
     } catch （InterruptedException e） {
       e.printStackTrace（）;
     }

     atomicCounter.counterIncrement（）;
   }

   public static void main（String[] args） throws Exception {
     AtomicCounter atomicCounter = new AtomicCounter（）;

     for （int i = 0; i < 5000; i++） {
       new AtomicCounterSample（atomicCounter）.start（）;
     }

     Thread.sleep（3000）;

     System.out.println（"counter=" + atomicCounter.getCounter（））;
   }
}

class AtomicCounter {
   private AtomicInteger counter = new AtomicInteger（0）;

   public int getCounter（） {
     return counter.get（）;
   }

   public void counterIncrement（） {
     for （; ;） {
       int current = counter.get（）;
       int next = current + 1;
       if （counter.compareAndSet（current, next））
         return;
     }
   }
}

class AtomicCounter2 {
   private volatile int counter;
   private static final AtomicIntegerFieldUpdater<AtomicCounter2> counterUpdater =  AtomicIntegerFieldUpdater.newUpdater（AtomicCounter2.class, "counter"）;

   public int getCounter（） {
     return counter;
   }

   public int counterIncrement（） {
//    return counter++;
     return counterUpdater.getAndIncrement（this）;
   }
}