AtomicInteger的认识与使用

我们知道，当多个线程对一个域访问时，会产生意想不到的后果，一个线程在还没来得及会写数据的时候，第二个线程已经访问了这个数据，这就使得数据产生问题，我们看个demo

package com.mingrisoft.thread;

import com.sun.org.apache.bcel.internal.generic.NEW;

public class Demo1 {


    Bank bank=new Bank();
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        new Demo1();
    }

    public Demo1() {
        // TODO Auto-generated constructor stub
          Thread thread=new Thread(new Run());
          thread.start();
           Thread thread1=new Thread(new Run());
           thread1.start();
    }

    class Run implements Runnable{
        public void run() {
            for(int i=0;i<10;i++){
                bank.setV(10);
            }
        }
    }

    class Bank{
        int v=100;

        public int getV() {
            return v;
        }
        public void setV(int va) {
            this.v +=va;
            System.out.println("数据为："+v);
        }
    }

}

对于这种情况，我们可以使用很对技术解决，例如
1.synchronized代码块，或者修饰方法，
2.使用特殊域 volatile关键字
3使用ReentrantLock
4.使用线程局部变量ThreadLocal
5.LinkedBlockingQueue阻塞队列实现
6.使用信号量Semaphore同步
7.使用原子变量实现AtomicInteger实现

具体应该还有，不过我就知道这几种，一般来说，还是喜欢用synchronized来实现，不比比了，我们还是说说今天的主人公
AtomicInteger
我们使用代码

package com.mingrisoft.thread;

import java.util.concurrent.atomic.AtomicInteger;

import com.sun.org.apache.bcel.internal.generic.NEW;

public class Demo1 {


    Bank bank=new Bank();
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        new Demo1();
    }

    public Demo1() {
        // TODO Auto-generated constructor stub
          Thread thread=new Thread(new Run());
          thread.start();
           Thread thread1=new Thread(new Run());
           thread1.start();
    }

    class Run implements Runnable{

        public void run() {
            for(int i=0;i<10;i++){
                bank.setV(10);
            }
        }
    }

    class Bank{
        AtomicInteger atomicInteger=new AtomicInteger(100);
        public int getV() {
            return atomicInteger.get();
        }
        public void setV(int va) {
            atomicInteger.addAndGet(va);
            System.out.println("当前的值为："+atomicInteger.get());
        }
    }

}

结果为

SO easy，简单几步，我们就解决了线程的同步问题
那么我们现在看看官方文档，加深下对这个类的理解

文档说的不明不白，原子？那么什么是原子方式？

所谓原子操作是指不会被线程调度机制打断的操作；这种操作一旦开始，就一直运行到结束，中间不会有任何 context switch （切[1] 换到另一个线程）。
百度上搜的，自己也不知道怎么解释，大致就是操作的不可分割性，不会受到线程的影响