java中的原子操作类AtomicInteger及其实现原理

        /**
         * 一，AtomicInteger 是如何实现原子操作的呢？
         *
         * 我们先来看一下getAndIncrement的源代码：
         *    public final int getAndIncrement() {
         *        for (;;) {
         *              int current = get();  // 取得AtomicInteger里存储的数值
         *            int next = current + 1;  // 加1
         *            if (compareAndSet(current, next))   // 调用compareAndSet执行原子更新操作
         *                return current;
         *        }
         *    }
         *
         * 这段代码写的很巧妙：
         * 1，compareAndSet方法首先判断当前值是否等于current；
         * 2，如果当前值 = current ，说明AtomicInteger的值没有被其他线程修改；
         * 3，如果当前值 != current，说明AtomicInteger的值被其他线程修改了，这时会再次进入循环重新比较；
         *    
         * 注意这里的compareAndSet方法，源代码如下：
         * public final boolean compareAndSet(int expect, int update) {
         *     return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
         * }
         *
         * 调用Unsafe来实现
         * private static final Unsafe unsafe = Unsafe.getUnsafe();
         *
         * 二，java提供的原子操作可以原子更新的基本类型有以下三个：
         *
         * 1，AtomicBoolean
         * 2，AtomicInteger
         * 3，AtomicLong
         *
         * 三，java提供的原子操作，还可以原子更新以下类型的值：
         *
         * 1，原子更新数组，Atomic包提供了以下几个类：AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray
         * 2，原子更新引用类型，也就是更新实体类的值，比如AtomicReference<User>
         * AtomicReference:原子更新引用类型的值
         * AtomicReferenceFieldUpdater:原子更新引用类型里的字段
         * AtomicMarkableReference:原子更新带有标记位的引用类型
         * 3，原子更新字段值
         * AtomicIntegerFieldUpdater:原子更新整形的字段的更新器
         * AtomicLongFieldUpdater:原子更新长整形的字段的更新器
         * AtomicStampedReference:原子更新带有版本号的引用类型的更新器
         *
         *

         */

示例代码如下：

import java.util.concurrent.atomic.AtomicInteger;
import sun.misc.Unsafe;

public class TestAtomic {

	/**
	 * @param java中的原子操作类AtomicInteger
	 * @author yangcq
	 * 
	 * 关于AtomicInteger的说明（来自官方文档注解）
	 * /**
	 * An {@code int} value that may be updated atomically.  See the
	 * {@link java.util.concurrent.atomic} package specification for
	 * description of the properties of atomic variables. An
	 * {@code AtomicInteger} is used in applications such as atomically
	 * incremented counters, and cannot be used as a replacement for an
	 * {@link java.lang.Integer}. However, this class does extend
	 * {@code Number} to allow uniform access by tools and utilities that
	 * deal with numerically-based classes.
	 *
	 * @since 1.5
	 * @author Doug Lea
	 */
	public static void main(String[] args) {
		// 初始值为1
		AtomicInteger atomicInteger = new AtomicInteger(1);
		System.out.println("--初始值atomicInteger = " + atomicInteger);
		
		// 以原子方式将当前值加1，注意这里返回的是自增前的值 
		System.out.println("atomicInteger.getAndIncrement() = " + atomicInteger.getAndIncrement());
		System.out.println("--自增后的 atomicInteger = " + atomicInteger);
		
		// 以原子方式将当前值减1，注意这里返回的是自减前的值 
		System.out.println("atomicInteger.getAndIncrement() = " + atomicInteger.decrementAndGet());
		System.out.println("--自减后的 atomicInteger = " + atomicInteger);
		
		// 以原子方式将当前值与括号中的值相加，并返回结果
		System.out.println("atomicInteger.getAndIncrement() = " + atomicInteger.addAndGet(10));
		System.out.println("--自减后的 atomicInteger = " + atomicInteger);
		
		// 如果输入的值等于预期的值，则以原子方式将该值设置成括号中的值
		System.out.println("atomicInteger.getAndIncrement() = " + atomicInteger.compareAndSet(1, 2));
		System.out.println("--自减后的 atomicInteger = " + atomicInteger);
		System.out.println("atomicInteger.getAndIncrement() = " + atomicInteger.compareAndSet(11, 9999));
		System.out.println("--自减后的 atomicInteger = " + atomicInteger);
		
		/**
		 * 一，AtomicInteger 是如何实现原子操作的呢？
		 * 
		 * 我们先来看一下getAndIncrement的源代码：
		 *    public final int getAndIncrement() {
		 *        for (;;) {
		 *	          int current = get();  // 取得AtomicInteger里存储的数值
		 *            int next = current + 1;  // 加1
		 *            if (compareAndSet(current, next))   // 调用compareAndSet执行原子更新操作
		 *                return current;
		 *        }
		 *    }
		 * 
		 * 这段代码写的很巧妙：
		 * 1，compareAndSet方法首先判断当前值是否等于current；
		 * 2，如果当前值 = current ，说明AtomicInteger的值没有被其他线程修改；
		 * 3，如果当前值 != current，说明AtomicInteger的值被其他线程修改了，这时会再次进入循环重新比较；
		 *    
		 * 注意这里的compareAndSet方法，源代码如下：
		 * public final boolean compareAndSet(int expect, int update) {
		 *     return unsafe.compareAndSwapInt(this, valueOffset, expect, update); 
		 * }
		 * 
		 * 调用Unsafe来实现
		 * private static final Unsafe unsafe = Unsafe.getUnsafe();
		 * 
		 * 二，java提供的原子操作可以原子更新的基本类型有以下三个：
		 * 
		 * 1，AtomicBoolean
		 * 2，AtomicInteger
		 * 3，AtomicLong
		 * 
		 * 三，java提供的原子操作，还可以原子更新以下类型的值：
		 * 
		 * 1，原子更新数组，Atomic包提供了以下几个类：AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray
		 * 2，原子更新引用类型，也就是更新实体类的值，比如AtomicReference<User>
		 * AtomicReference:原子更新引用类型的值
		 * AtomicReferenceFieldUpdater:原子更新引用类型里的字段
		 * AtomicMarkableReference:原子更新带有标记位的引用类型
		 * 3，原子更新字段值
		 * AtomicIntegerFieldUpdater:原子更新整形的字段的更新器
		 * AtomicLongFieldUpdater:原子更新长整形的字段的更新器
		 * AtomicStampedReference:原子更新带有版本号的引用类型的更新器
		 * 
		 * 
		 */
	}

}

四，AtomicIntegerFieldUpdater:原子更新整形的字段的更新器

import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;

public class TestAtomicIntegerFieldUpdater {

	/**
	 * @param AtomicIntegerFieldUpdater:原子更新整形的字段的更新器
	 * @author yangcq
	 */
	
	// 创建原子更新器，并设置需要更新的对象类和对象的属性
	private static AtomicIntegerFieldUpdater<User> atomicIntegerFieldUpdater 
		= AtomicIntegerFieldUpdater.newUpdater(User.class, "age");
	
	public static void main(String[] args) {
		
		// 设置age的初始值为1000
		User user = new User();
		user.setUserName("yangcq");
		user.setAge(1000);
		
		// 原子更新引用数据类型的字段值
		System.out.println(atomicIntegerFieldUpdater.getAndIncrement(user));
		// 更新以后的值
		System.out.println(atomicIntegerFieldUpdater.get(user));
	}
	
	//实体类User
	public static class User{
		private String userName;
		public volatile int age;

		// setter、getter方法
		public String getUserName() {
			return userName;
		}
		public void setUserName(String userName) {
			this.userName = userName;
		}
		public int getAge() {
			return age;
		}
		public void setAge(int age) {
			this.age = age;
		}
	}

}

五，java原子操作类在实际项目中的应用（java原子操作类的应用场景）

java原子操作类 AtomicInteger 在实际项目中的应用。HttpClientFacotryBean工厂会工作在多线程环境中，生成Httpclient，
就相当于建立HttpClient连接，通过工厂模式控制HttpClient连接，能够更好的管理HttpClient的生命周期。而我们使用java原子
操作类AtomicInteger来控制计数器，就是为了保证，在多线程的环境下，建立HttpClient连接不会出错，不会出现2个线程竞争一个
HttpClient连接的情况。

bean配置如下：
    <bean id="Httpclient" name="httpclient" class="com.yangcq.initBean.HttpClientFacotryBean">
        <property name="connectionManager" ref="connectionManagers" ></property>
        <property name="map">
            <map>
                <entry key="http.socket.timeout" value="30000" />
                <entry key="http.connection.timeout" value="30000" />
                <entry key="http.conn-manager.timeout"  value="6000" />
            </map>
        </property>
    </bean>

java实现类：
import java.io.IOException;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
import org.apache.http.HttpException;
import org.apache.http.HttpRequest;
import org.apache.http.HttpRequestInterceptor;
import org.apache.http.client.HttpClient;
import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.conn.params.ConnManagerPNames;
import org.apache.http.conn.params.ConnManagerParamBean;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.CoreConnectionPNames;
import org.apache.http.params.HttpConnectionParamBean;
import org.apache.http.params.HttpParams;
import org.apache.http.protocol.HttpContext;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.BeanInitializationException;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.InitializingBean;
/**
 * 在容器启动时注入connectionManager，然后初始化httpClient
 * 主要参数：
 * CONNECTION_TIMEOUT : 连接主机超时时间设置
 * SO_TIMEOUT :         读取主机数据超时时间设置
 * TIMEOUT :            获取连接超时时间
 */
public class HttpClientFacotryBean implements FactoryBean,InitializingBean,DisposableBean {
	private static final Logger logger = Logger.getLogger(HttpClientFacotryBean.class);
	private DefaultHttpClient httpClient;
	private ClientConnectionManager clientConnectionManager = null;
	private Map map = null;	
	//设置httpClient超时参数
	public void afterPropertiesSet() throws Exception {
		if (null == clientConnectionManager) {
			throw new BeanInitializationException("The connection manager must be set in " + this.getClass().getName() + "...");
		}
		HttpParams httpParams = new BasicHttpParams();
		if (null != map) {
			HttpConnectionParamBean httpConnectionParamBean = new HttpConnectionParamBean(httpParams);
			String connectionTimeout = (String) map.get(CoreConnectionPNames.CONNECTION_TIMEOUT);
			if (null != connectionTimeout)
				httpConnectionParamBean.setConnectionTimeout(Integer.parseInt(connectionTimeout));
			String soTimeout = (String) map.get(CoreConnectionPNames.SO_TIMEOUT);
			if (null != connectionTimeout)
				httpConnectionParamBean.setSoTimeout(Integer.parseInt(soTimeout));
			ConnManagerParamBean connManagerParamBean = new ConnManagerParamBean(httpParams);
			String timeout = (String) map.get(ConnManagerPNames.TIMEOUT);
			if (null != timeout)
				connManagerParamBean.setTimeout(Long.parseLong(timeout));
		}
		this.httpClient = new DefaultHttpClient(clientConnectionManager, httpParams);
		this.httpClient.addRequestInterceptor(new HttpRequestInterceptor() {
			public void process(final HttpRequest request,final HttpContext context) throws HttpException,IOException {
				AtomicInteger count = (AtomicInteger) context.getAttribute("count"); // 从HttpContext中获取计数器count
				if (null == count) {
					count = new AtomicInteger(1); // 如果计数器为空，则初始化值为1
					context.setAttribute("count", count); // 放到context中
				}
				request.addHeader("Count", Integer.toString(count.getAndIncrement())); // 把计数器放到request请求中
				if (logger.isDebugEnabled()) {
					logger.debug("\n=====这是第 " + count + " 次连接=====\n");
				}
			}
		});
	}
	public void destroy() throws Exception {
		if (null != params)
			map.clear();
		if (null != clientConnectionManager)
			clientConnectionManager.closeExpiredConnections();
	}
	public ClientConnectionManager getConnectionManager() {
		return clientConnectionManager;
	}
	public Map getParams() {
		return map;
	}
	public void setConnectionManager(ClientConnectionManager clientConnectionManager) {
		this.clientConnectionManager = clientConnectionManager;
	}
	public void setParams(Map map) {
		this.map = map;
	}
	public Object getObject() throws Exception {
		return this.httpClient;
	}	
	public Class getObjectType() {
		return HttpClient.class;
	}
	public boolean isSingleton() {
		return false;
	}
}