高级并发编程学习-atomic包学习（重点介绍AtomicInteger、AtomicIntegerFieldUpdater）

Java.util.concurrent两个子包locks&atomic,官网文档介绍为可以对基本数据、数组中的基本数据、对类中的基本数据进行操作。

一 atomic包

1.      原子性定义：原子性意味着个时刻，只有一个线程能够执行一段代码，这段代码通过一个monitor object保护，从而防止多个线程在更新共享状态时相互冲突。经过atomic类修饰的变量具备原子性，不必考虑在多线程并发条件下的线程安全问题。

(2)对类中的某个成员变量进行修改

使用方法：

//导入concurrent包下面的AtomicInteger内容
import java.util.concurrent.atomic.AtomicInteger;

public class TestAtomic {// 测试concurrent包下的AtomicInteger
	public static AtomicInteger i = new AtomicInteger(0);// 所有的线程操作同一个对象
	public static int A = 0;

	public static void main(String[] args) throws InterruptedException {
		System.out.println("i累计前"+TestAtomic.i+",A累计前："+TestAtomic.A);
	Thread t0=	new Thread(
		new Runnable(){

			@Override
			public void run() {
				for(int j=0;j<100000;j++)
				{
					
					TestAtomic.A++;
					TestAtomic.i.getAndIncrement();
				}		
			}
	});
	Thread t1=	new Thread(
				new Runnable(){

					@Override
					public void run() {
						for(int j=0;j<100000;j++)
						{
							
							TestAtomic.A--;
							TestAtomic.i.decrementAndGet();
						}		
					}
			});
	t0.start();
	t1.start();
	t0.join();
	t1.join();
		
		System.out.print("i累计后"+TestAtomic.i+",A累计后："+TestAtomic.A);
	
}
}

上述代码的运行结果为：

i累计前0,A累计前：0

i累计后0,A累计后：24531

从上述代码中我们可以看出，变量i保证了结果的正确性，原因在于i采用的是AtomicInteger 属性，变量具备原子性，从而保证了该变量是线程安全的。

(2)对已经new出来的某个变量进行修改，保证其原子性。

AtomicIntegerFieldUpdater使用最重要的在于其构造函数，我们可以在其api文件中查看

public static <U> AtomicIntegerFieldUpdater<U>newUpdater(Class<U> tclass,

                                                         String fieldName)

使用方法：

private AtomicIntegerFieldUpdater<Details>

        atomicIntegerFieldUpdater = AtomicIntegerFieldUpdater.newUpdater(

                Details.class, "numberTimesInvoked" );

详细使用代码：

import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;

/**
 * volatiles cannot be used directly in operations that do x = x + 1 for
 * numbers can be skipped or duplicated when there are multiple threads
 * involved.
 * <p>
 * Hardware supports Atomic Compare And Swap operations.  CAS java classes
 * like AtomicInteger can use this feature of the hardware to ensure that
 * a "x = x + 1" like operation is atomic.
 * <p>
 * However AtomicInteger is significantly more resource intensive than a simple
 * volatile. If there are many instances of a class which has an AtomicInteger
 * this increase in resource over a volatile can be significant.
 * <p>
 * The AtomicIntegerFieldUpdater comes to the rescue - it can be registered
 * with a volatile variable of a class and can then be used on multiple
 * instances of the class.
 *
 * If there are 1000s of instances of a class which would ordinarily have
 * AtomicInteger this can be a big saving.
 *
 * AtomicIntegerFieldUpdater is able to update a volatile field of an object
 * atomically.
 *
 * @author John Dickerson
 */
public class AtomicIntegerFieldUpdaterCounter {

    // AtomicIntegerFieldUpdater is registered with Details.class so that it
    // knows it will later be updating the volatile field called
    // numberTimesInvoked
	//步骤1 构造方法
    private AtomicIntegerFieldUpdater<Details>
        atomicIntegerFieldUpdater = AtomicIntegerFieldUpdater.newUpdater(
                Details.class, "numberTimesInvoked" );


    /**
     * Diferent threads can call this method to update the volatile field of
     * an instance of Details
     *
     * @param details Details object which has the volatile field called
     * "numberTimesInvoked" in it.
     *
     * @return the value of the counter after it has been incremented by one
     */
    //步骤2 对AtomicIntegerFieldUpdater修饰的变量进行操作
    public int addOne( Details details ){

        // performs a "x = x + 1" style atomic operation
        //return atomicIntegerFieldUpdater.addAndGet( details, 1 );
    	return this.atomicIntegerFieldUpdater.getAndIncrement(details);
    }
    public int subOne(Details details)
    {
    	return atomicIntegerFieldUpdater.decrementAndGet(details);
    }


    /**
     * See test class for example of using this class with multiple threads,
     * some of which are writing to the volatile field and some which are
     * reading from the volatile field
     * @throws InterruptedException 
     */
    public static void main(String[] args) throws InterruptedException {

     final    AtomicIntegerFieldUpdaterCounter atomicIntegerFieldUpdaterCounter =
            new AtomicIntegerFieldUpdaterCounter();

        // This call would ordinarily be made by many other threads
     final   Details d=new Details();
        System.out.print("对象d的变量numberTimesInvoked累计前:"+d.getNumberTimesInvoked());
        System.out.println(",A累计前："+TestAtomic.A);
    	Thread t0=	new Thread(
    		new Runnable(){

    			@Override
    			public void run() {
    				for(int j=0;j<100000;j++)
    				{
    					
    					atomicIntegerFieldUpdaterCounter.addOne(d);
    					TestAtomic.A++;
    				}		
    			}
    	});
    	Thread t1=	new Thread(
    				new Runnable(){

    					@Override
    					public void run() {
    						for(int j=0;j<100000;j++)
    						{
    							TestAtomic.A++;
    							atomicIntegerFieldUpdaterCounter.subOne(d);
    						}		
    					}
    			});
    	t0.start();
    	t1.start();
    	t0.join();
    	t1.join();
    		
    	 System.out.print("对象d的变量numberTimesInvoked累计后:"+d.getNumberTimesInvoked());
         System.out.println(",A累计后："+TestAtomic.A);
    }
}

/**
 * @author John Dickerson
 */
public class Details {

    volatile int numberTimesInvoked;

    public int getNumberTimesInvoked() {

        return numberTimesInvoked;
    }

    public void setNumberTimesInvoked(int numberTimesInvoked) {

        this.numberTimesInvoked = numberTimesInvoked;
    }
}

运行结果如下：

对象d的变量numberTimesInvoked累计前:0,A累计前：0

对象d的变量numberTimesInvoked累计后:0,A累计后：199947

从上述代码中我们可以看出，新创建的：Details d=newDetails();对象d的变量numberTimesInvoked，经过this.atomicIntegerFieldUpdater.getAndIncrement(d); 构造后成了一个线程安全的变量。