【java总结】多线程进阶篇之atomic包

在java语言中，类似i++这种操作并不是原子性的。它并非线程安全的语句，在实际使用中，我们经常需要使用synchronized语句来保证数据的正确。现如今，大多数处理器都包含原子性指令，常见的指令是CAS(compare and set)和TAS(test and set)，是一种加锁的原子操作指令。

CAS 操作

包含三个操作数 ——内存位置（V）、预期原值（A）和新值(B)。如果内存位置的值与预期原值相匹配，那么处理器会自动将该位置值更新为新值。否则，处理器不做任何操作。CAS执行结果要么成功要么失败，对于失败的情形下一班采用不断重试。或者放弃。

在java.util.concurrent.atomic包中，所有类都使用了原子变量，它并不用同步来实现，因此大大提高了效率。

atomic包含有的类如下：

AtomicBoolean 可以用原子方式更新的 boolean 值。   

AtomicInteger 可以用原子方式更新的 int 值。   

AtomicIntegerArray 可以用原子方式更新其元素的 int 数组。   

AtomicIntegerFieldUpdater<T> 基于反射的实用工具，可以对指定类的指定 volatile int 字段进行原子更新。   

AtomicLong 可以用原子方式更新的 long 值。   

AtomicLongArray 可以用原子方式更新其元素的 long 数组。   

AtomicLongFieldUpdater<T> 基于反射的实用工具，可以对指定类的指定 volatile long 字段进行原子更新。   

AtomicMarkableReference<V> AtomicMarkableReference 维护带有标记位的对象引用，可以原子方式对其进行更新。   

AtomicReference<V> 可以用原子方式更新的对象引用。   

AtomicReferenceArray<E> 可以用原子方式更新其元素的对象引用数组。   

AtomicReferenceFieldUpdater<T,V> 基于反射的实用工具，可以对指定类的指定 volatile 字段进行原子更新。   

AtomicStampedReference<V> AtomicStampedReference 维护带有整数“标志”的对象引用，可以用原子方式对其进行更新。   

 

public class AtomicBooleanTest {
	/** 
	06.     * 主要方法： 
	07.     * @see AtomicBoolean#compareAndSet(boolean, boolean)  第一个参数为原始值，第二个参数为要修改的新值，若修改成功则返回true，否则返回false 
	08.     * @see AtomicBoolean#getAndSet(boolean)   尝试设置新的boolean值，直到成功为止，返回设置前的数据 
	09.     */  

	public final static AtomicBoolean TEST_BOOLEAN = new AtomicBoolean();  
	public static void main(String[] args){
		for(int i=0;i<10;i++){
			new Thread(){
				public void run(){
					try{
						Thread.sleep(1000);
					}catch(InterruptedException e){
						e.printStackTrace();
					}
					if(TEST_BOOLEAN.compareAndSet(false, true)){
						System.out.println("我是线程"+Thread.currentThread().getName()+"我成功了！");
					}else 
						System.out.println("我是线程"+Thread.currentThread().getName()+"我失败了！");
				}
			}.start();
		}
	}
}

public class AtomicIntegerTest {
	public final static AtomicInteger TEST_INTEGER=new AtomicInteger(1);
		public static void main(String[] args)throws InterruptedException {
			final Thread[] threads=new Thread[10];
			for(int i=0;i<10;i++){
				final int num=i;
				threads[i]=new Thread(){
					public void run(){
						try{
							Thread.sleep(1000);
						}catch(InterruptedException e){
							e.printStackTrace();
						}
						int now=TEST_INTEGER.incrementAndGet();
						System.out.println("我是线程"+num+",我得到了值，增加后的值为："+now);
					}
				};
				threads[i].start();
			}
			for(int i=0;i<10;i++){
				threads[i].join();
			}
			System.out.println("最终结果："+TEST_INTEGER.get());
		}
}

public class AtomicIntegerArrayTest {
	private final static AtomicIntegerArray ATOMIC_INTEGER_ARRAY = new AtomicIntegerArray(new int[]{1,2,3,4,5,6,7,8,9,10});
	public static void main(String []args) throws InterruptedException {
		Thread []threads = new Thread[100];
		for(int i = 0 ; i < 100 ; i++) {
			final int index = i % 10;
			final int threadNum = i;
			threads[i] = new Thread() {
				public void run() {
					int result = ATOMIC_INTEGER_ARRAY.addAndGet(index, index + 1);
					System.out.println("线程编号为：" + threadNum + " , 对应的原始值为：" + (index + 1) + "，增加后的结果为：" + result);
				}
			};
			threads[i].start();
		}
		for(Thread thread : threads) {
			thread.join();
		}
		System.out.println("=========================>\n执行已经完成，结果列表：");
		for(int i = 0 ; i < ATOMIC_INTEGER_ARRAY.length() ; i++) {
			System.out.println(ATOMIC_INTEGER_ARRAY.get(i));
		}
	}

}

ABA问题：如果一个线程修改V值假设原来是A，先修改成B，再修改回成A。当前线程的CAS操作无法分辨当前V值是否发生过变化。举个例子，你把屋子收拾干净之后，有事出门一趟，这时屋子整齐的状态成为A，在你出门的这段时间，有人把你的屋子弄乱，翻来翻去。这时脏乱的状态成为B，之后，又帮你恢复到原样，当你回家的时候，你看到的是状态A，你以为你的屋子一直存在于状态A，而实际上它经历了ABA这个过程。

public class AtomicReferenceTest {
	public final static AtomicReference <String>ATOMIC_REFERENCE = new AtomicReference<String>("abc"); 
	public static void main(String[] args){
		for (int i=0;i<100;i++){
			final int num=i;
			new Thread(){
				@Override
				public void run(){
					try{
						Thread.sleep((int)(Math.random()*100));
					}catch(InterruptedException e){
						e.printStackTrace();
					}
					if(ATOMIC_REFERENCE.compareAndSet("abc", "abc2")){
						System.out.println("我是线程"+num+"我获得了锁进行了对象修改！");
					}
				}
			}.start();
		}
		new Thread(){
			@Override 
			public void run(){
				while(!ATOMIC_REFERENCE.compareAndSet("abc2", "abc"));
				System.out.println("已经改为原始值!");
			}
		}.start();
	}
}

 

public class AtomicStampedReferenceTest {
	/*
	 * 将abc修改为abc2的线程仅有一个被访问，虽然被修改回了原始值，但
	 * 是其他线程也不会再将abc改为abc2。
	 */
	public final static AtomicStampedReference <String>ATOMIC_REFERENCE = new AtomicStampedReference<String>("abc" , 0);  
	public static void main(String []args) {
		for(int i = 0 ; i < 100 ; i++) {
			final int num = i; 
			final int stamp = ATOMIC_REFERENCE.getStamp();  
			 new Thread() {
				 public void run(){
					 try {
						 Thread.sleep(Math.abs((int)(Math.random() * 100))); 
					 }catch (InterruptedException e){
						 e.printStackTrace(); 
					 }
					 if(ATOMIC_REFERENCE.compareAndSet("abc" , "abc2" , stamp , stamp + 1)){
						 System.out.println("我是线程：" + num + ",我获得了锁进行了对象修改！");  

					 }
				 }
			 }.start();
		}
		new Thread(){
			public void run(){
				int stamp=ATOMIC_REFERENCE.getStamp();
				while(!ATOMIC_REFERENCE.compareAndSet("abc2", "abc" , stamp , stamp + 1));  
				System.out.println("已经改回为原始值！");  

			}
		}.start();
	}
}

  总结：使用atomic包下的各种类来处理线程线程之间的竞争要比使用synchronized关键字要高效的多，尽量使用原子类。