线程并发相关的原子操作类

#线程并发原子操作类

何为原子性，就是一次性操作完成，在操作变量的时候，其它线程不能操作变量，也就是我们之前说的synchronized同步关键字的作用。这节我们不用synchronized，而是用系统API中的原子类，今天我们以其中一个AtomicInteger类为例来讲解。

比如我们有20个人同时卖票，每人卖1000张，问最后总共卖了多少张？这里先给出答案：20000张。
我们来看下代码如何编写，20个人相当于20个线程，然后每个线程内for循环1000次，每次给票数加1，那么java代码就是：

模拟20个人一起卖票

public class ThreadAtomicTest {

	static int ticketNums = 0; //最终票数

	public static void main(String[] args) {

		for(int i = 0; i < 20; i++){
		new Thread(new Runnable(){

			public void run() {
				for(int i = 0; i < 1000; i++){
					ticketNums++ ;
				}
				try {
					Thread.sleep(5);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}).start();
		}
		
		while (Thread.activeCount() > 1) {
            Thread.yield();
        }

		System.out.println("ticketNums="+ticketNums);
	 }

 } //类结束

代码解析：

new Thread生成一个线程，run方法内的for循环1000次，表示1个人卖1000张票，然后外围for循环20下，表示20个人同时卖票，即20个线程
代表20个售票员。最后System.out输出卖票总数。 while循环是为了阻止主线程结束，否则的话main函数会很快执行完，子线程还没执行完就
退出了。

运行3次，查看结果都不是20000张，说明有问题，打印的票数如下：

ticketNums=18434
ticketNums=17564
ticketNums=16596

这是为什么呢？ 原因是ticketNums +=1 这行代码没有加同步锁。举个例子，当第1个线程执行到ticketNums++时，它读出了ticketNums的初始值0，这个时候线程2还没等线程1执行完++运算符，也读取出了ticketNums的初始值0，最终2个线程都是对0进行 ++运算符，最终线程1++的结果是1，线程2 ++的结果也是1，本应两人卖了2张票，结果算出票数却是1，少算1张。 类似于这样多线程抢着对公共变量（临界资源）进行操作，带来了不同步性。那么，要解决这个问题的关键就是让线程同步，当1个线程操作变量++时，其它线程不能插手，那么我先用synchronized来实现一下。

java代码如下（使用synchronized实现操作变量的原子性）

public class ThreadAtomicTest {

	static int ticketNums = 0;

	public static void main(String[] args) {
		for(int i = 0; i < 20; i++){
			new Thread(new Runnable(){

				public void run() {
					for(int i = 0; i < 1000; i++){
						synchronized (ThreadAtomicTest.class){
						    ticketNums++;	
						}
					}
					try {
						Thread.sleep(5);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}).start();
		}
		while (Thread.activeCount() > 1) {
            Thread.yield();
        }
		System.out.println("ticketNums="+ticketNums);
	}

} //类结束

代码解析：
这次我们给ticketNums++的外围加了synchronized同步锁关键字，这里的锁用的是一个类的字节码，当然我们也可以用一个静态对象当作锁，只要保证各线程用的是同一把锁对象即可。最终运行的票数结果是：20000，正确！

接着我们用今天的AtomicInteger类来实现上述synchronized的效果，我没看单词AtomicInteger就知道它是原子操作，专门用来操作int数值的，它能控制ticketNums++操作一气呵成后，才允许其它线程操作ticketNums.我们通过调用AtomicInteger的 incrementAndGet函数类实现，具体代码如下：

java使用AtomicInteger在多线程里对变量++

import java.util.concurrent.atomic.AtomicInteger;

public class ThreadAtomicTest {
	static AtomicInteger ticketNums = new AtomicInteger(0);
	public static void main(String[] args) {
		for(int i = 0; i < 20; i++){
			new Thread(new Runnable(){
	
				public void run() {
					for(int i = 0; i < 1000; i++){
						ticketNums.incrementAndGet();
					}
					try {
						Thread.sleep(5);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}).start();
		}
		while (Thread.activeCount() > 1) {
            Thread.yield();
        }

	  System.out.println("ticketNums="+ticketNums.get());
	}

}

代码解析
static AtomicInteger ticketNums = new AtomicInteger(0);new一个AtomicInteger对象，里面存储的int值初始为0，然后，在多线程的run()方法里调用ticketNums.incrementAndGet();表示对int值进行++，并返回当前值，最重要的是它不被其它线程打扰，它是一气呵成执行的原子操作。

好的，今天就探讨到这里。