关于volatile类型变量的一点思考

被volatile 修饰的变量有以下如下重要特点：在引用这种变量的线程之间，被修饰的变量能够保证其“可见性”。

也就是说，假如X线程修改了a，这条数据会立即更新到内存区域中，Y线程再读取的时候也是从内存中读取,会读取到a变量更新后的值。反过来，假如a变量不用volatile修饰，那么当X修改了a变量时,有可能仅仅将a修改后的值保存在了catch中，此时新的a值对X可见对Y不可见，Y值有可能会获取a的“脏数据”。

说清了这个概念，再看看下面的代码。功能是两个线程同时对a进行 +1操作，各加10000遍。

public class IntegerCountTest {
	
	static volatile Integer a = 0;
	
	
	static class MyTask implements Runnable{
		
		CountDownLatch ct;
		
		public MyTask( CountDownLatch ct2) {
			this.ct = ct2;
		}

		@Override
		public void run() {
			for(int i=0;i<10000;i++) {
				a = a+1;

			}
			this.ct.countDown();
		}
	}

	public static void main(String[] arg) {

		CountDownLatch ct = new CountDownLatch(2);
		
		Thread t1 = new Thread(new MyTask(ct));
		Thread t2 = new Thread(new MyTask(ct));
		
		t1.start();
		t2.start();
		
		try {
			ct.await();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		System.out.println(a);
	}
}

 按直觉将，最终输出的a应该是20000，但实际a 是一个趋近于20000的随机数。既然 a被volatile 修饰,能够保证 在t1 和 t2之间的可见性，那么为什么还会出现这种情况？

因为 a = a+1;不是一个原子操作。

这行代码至少会作2个操作，先是获取a的值，加1生成新的值再赋值给a变量。可能t1 和t2同时运行到 a = a+1这一行，同时获取了a的旧值x ，然后先后将同一个x+1的值赋值给了x。这样就导致了这种情况。

怎么解决？将a = a+1变为一个原子操作，如下所示，将a定义成AtomicInteger 变量，其中a.incrementAndGet();操作能够保证+1操作的原子性。

public class IntegerCountTest {
	
	//static volatile Integer a = 0;
	//static Integer a = 0;
	static AtomicInteger a = new AtomicInteger(0);
	
//	private static  sun.misc.Unsafe UNSAFE ;
//	 private static  long aOffset ;
//	static {
//		UNSAFE = sun.misc.Unsafe.getUnsafe();
//		Class<?> k = IntegerCountTest.class;
//		try {
//			aOffset = UNSAFE.objectFieldOffset(k.getDeclaredField("a"));
//		} catch (NoSuchFieldException e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		} catch (SecurityException e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		}
//	}
	
	static class MyTask implements Runnable{
		
		CountDownLatch ct;
		
		public MyTask( CountDownLatch ct2) {
			this.ct = ct2;
		}

		@Override
		public void run() {
			for(int i=0;i<10000;i++) {
				//a = a+1;
				

//				for(;;) {
//					int temp = a;
//					int newvar = temp+1;
//					if(UNSAFE.compareAndSwapInt(this, aOffset, newvar, temp)) {
//						break;
//					}
//				}

				
				a.incrementAndGet();
			}
			this.ct.countDown();
		}
	}

	public static void main(String[] arg) {

		CountDownLatch ct = new CountDownLatch(2);
		
		Thread t1 = new Thread(new MyTask(ct));
		Thread t2 = new Thread(new MyTask(ct));
		
		t1.start();
		t2.start();
		
		try {
			ct.await();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		System.out.println(a);
	}
}

当然，还有其他很多方法可以实现，比如加锁，以及jvm内部使用的UNSAFE方法等。