Java并发控制synchronized与AtomicInteger类

众所周知，在Java多线程编程中，一个非常重要的方面就是线程的同步问题。关于线程的同步，最常用的解决方法就是使用synchronized关键字，但是如果使用场景只用在控制一个计数的整型变量时(通常这也是非常常见的一个使用场景)，另一种实现方式AtomicInteger类简洁易用的特性一定会让你对它爱不释手。
我们先通过一个简单的例子模拟下多线程并发计数，程序如下

public class ShareData {public static int count=0;public static void main(String[] args){final ShareData data  = new ShareData();for(int i=0;i<10;i++){new Thread(new Runnable(){public void run(){try{Thread.sleep(1);}catch(InterruptedException e){e.printStackTrace();}for(int j=0;j<100;j++){data.addCount();}System.out.print(count+" ");}}).start();}try{Thread.sleep(3000);}catch(InterruptedException e){e.printStackTrace();}System.out.print("count="+count);}public void addCount(){count++;}}

程序启动了十个线程，每个线程计100次数，操作的都是count这个变量，最后在等待3秒（所有线程均执行结束后）输出此时的count值，每次执行后的输出结果都不一定一样，但是一般count小于1000，结果如下：

100 224 373 473 373 255 823 791 691 591 count=823

344 566 366 299 299 466 366 669 695 769 count=769

400 400 400 500 400 615 913 813 713 713 count=913

我们将addCount（）方法加上synchronized关键词修饰下，让它实现线程安全，

public synchronized void addCount(){count++;}

再执行，结果如下：

200 200 411 677 774 864 1000 666 1000 891 count=1000

423 909 1000 428 802 512 691 706 512 914 count=1000

300 500 500 300 300 712 809 850 949 1000 count=1000

此时可以看出最终count的数值都会精确的是1000，讲完了synchronized之后我们再来看下AtomicInteger类

AtomicInteger类可以用原子方式更新的 int 值，主要用于在高并发环境下的高效程序处理，使用非阻塞算法来实现并发控制，它的方法有

//获取当前的值public final int get()//取当前的值，并设置新的值public final int getAndSet(int newValue)//获取当前的值，并自增public final int getAndIncrement() //获取当前的值，并自减public final int getAndDecrement()//获取当前的值，并加上预期的值public final int getAndAdd(int delta) 

这里我们依然用上面的程序做例子，使用AtomicInteger类来替代synchronized方式，代码如下：

package concurrent;import java.util.concurrent.atomic.AtomicInteger;public class ShareData_AtomicInteger {static AtomicInteger count = new AtomicInteger(0);public static void main(String[] args){final ShareData_AtomicInteger data  = new ShareData_AtomicInteger();for(int i=0;i<10;i++){new Thread(new Runnable(){public void run(){try{Thread.sleep(1);}catch(InterruptedException e){e.printStackTrace();}for(int j=0;j<100;j++){data.addCount();}System.out.print(count.get()+" ");}}).start();}try{Thread.sleep(3000);}catch(InterruptedException e){e.printStackTrace();}System.out.print("count="+count.get());}public void addCount(){count.getAndIncrement();}}

执行结果如下：

495 528 604 504 987 657 741 682 1000 925 count=1000

500 500 984 823 499 733 500 495 601 1000 count=1000

409 409 436 409 700 587 600 872 988 1000 count=1000

至此结束，AtomicInteger只是concurrent下的一个整数原子操作类，该包下还有很多其他关于线程锁同步的机制，有兴趣的同学可以自行搜索下相关资料~谢谢