java中什么叫原子操作？

就是无法被别的线程打断的操作。要么不执行，要么就执行成功。例如：x=3是原子操作。过程就是先把工作内存的x赋成3，再把主存的x赋成3。y=x不是原子操作，它涉及在工作内存先把x值读出来，再把这个值赋给y。x++或x=x+1也不是原子操作，它涉及取值，自加和赋值。下面我们就用一个例子来说明x ++不是原子操作所带来的问题。马克- to-win：马克 java社区：防盗版实名手机尾号： 73203。


class NumContainer {
    int num;
}
class MulThreMarkToWin extends Thread {
    NumContainer nc;
    public void increase() {
        nc.num++;
    }
    public MulThreMarkToWin(NumContainer nc) {
        this.nc = nc;
    }
    public void run() {
        increase();
    }
}

public class TestMark_to_win {
    public static void main(String[] args) {
        NumContainer nc = new NumContainer();
        MulThreMarkToWin[] threads = new MulThreMarkToWin[10000];
        for (int i = 0; i < 10000; i++) {
            threads[i] = new MulThreMarkToWin(nc);
        }
        for (int i = 0; i < 10000; i++) {
            threads[i].start();
        }
        try {
            Thread.sleep(6000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(nc.num);
    }
}

输出结果是：

9997

结果为什么不是10000？10000个线程都执行一遍num++;按理说结果应该是10000。现在的结果却总是小于等于10000。这就要从++操作的非原子性讲起。想象在某个时刻，两个线程同时读出num值等于30，同时又在自己的工作内存做了++操作，之后先后把 31重新写回主存。这样结果就小于10000了。顺便说一句，这种情况即使加了volatile关键字，也解决不了问题。有volatile也照样覆盖，因为volatile只能保证读时是最新的。但他解决不了原子问题。像刚才这样，该覆盖时照样覆盖。那怎么解决呢？只有通过原子操作。

import java.util.concurrent.atomic.AtomicInteger;

class MulThreMarkToWin extends Thread {
    private AtomicInteger inc;
    public void increase() {
        inc.getAndIncrement();
    }
    public MulThreMarkToWin(AtomicInteger inc) {
        this.inc = inc;
    }
    public void run() {
        increase();
    }
}

public class TestMark_to_win {
    public static void main(String[] args){
        AtomicInteger inc = new AtomicInteger();
        MulThreMarkToWin[] threads = new MulThreMarkToWin[10000];
        for (int i = 0; i < 10000;i++) {
            threads[i] = new MulThreMarkToWin(inc);
        }
        for (int i = 0; i < 10000;i++) {
            threads[i].start();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(inc);
    }
}

输出结果是：
10000