java之原子性

1.定义：

原子操作是指一个不受其他操作影响的操作任务单元。原子操作是在多线程环境下避免数据不一致必须的手段。

i++并不是一个原子操作，所以当一个线程读取它的值并加1时，另外一个线程有可能会读到之前的值，这就会引发错误。

为了解决这个问题，必须保证增加操作是原子的，在JDK1.5之前我们可以使用同步技术来做到这一点。到JDK1.5，java.util.concurrent.atomic包提供了int和long类型的装类，它们可以自动的保证对于他们的操作是原子的并且不需要使用同步

让我们创建一个简单的多线程程序,每一个线程增加共享变量4次。如果有两个线程,完成后计算值应该是8。例子如下：

package com.journaldev.concurrency;
 
 
public class JavaAtomic {
 
    public static void main(String[] args) throws InterruptedException {
 
        ProcessingThread pt = new ProcessingThread();
        Thread t1 = new Thread(pt, "t1");
        t1.start();
        Thread t2 = new Thread(pt, "t2");
        t2.start();
        t1.join();
        t2.join();
        System.out.println("Processing count=" + pt.getCount());
    }
 
}
 
 
class ProcessingThread implements Runnable {
    private int count;
 
 
    @Override
    public void run() {
        for (int i = 1; i < 5; i++) {
            processSomething(i);
            count++;
        }
    }
 
 
    public int getCount() {
        return this.count;
    }
 
 
    private void processSomething(int i) {
        // processing some job
        try {
            Thread.sleep(i * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
 
}

如果你将运行上面的程序,你会发现计算值之间的不同5,6,7,8。 原因是count + +不是一个原子操作。 所以当一个线程读到它值并且增加,但是其他线程读到了旧值导致错误的结果。
为了解决这个问题,我们必须确保增量计数是原子操作,我们可以使用同步,但Java 5 Java . util . concurrent， 为int，long提供包装类可以用来实现这一目标而不需同步。

2.原子方法：

package com.journaldev.concurrency;
 
import java.util.concurrent.atomic.AtomicInteger;
 
 
public class JavaAtomic {
 
    public static void main(String[] args) throws InterruptedException {
 
        ProcessingThread pt = new ProcessingThread();
        Thread t1 = new Thread(pt, "t1");
        t1.start();
        Thread t2 = new Thread(pt, "t2");
        t2.start();
        t1.join();
        t2.join();
        System.out.println("Processing count=" + pt.getCount());
    }
 
}
 
 
class ProcessingThread implements Runnable {
    private AtomicInteger count = new AtomicInteger();
 
 
    @Override
    public void run() {
        for (int i = 1; i < 5; i++) {
            processSomething(i);
            count.incrementAndGet();
        }
    }
 
 
    public int getCount() {
        return this.count.get();
    }
 
 
    private void processSomething(int i) {
        // processing some job
        try {
            Thread.sleep(i * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
 
}

3.总结：

使用原子并发类的好处是,我们不需要担心同步，而且我认为更有效率,可以帮助我们同步包括锁定资源。

注：关键代码：

private int count;

count++;

return this.count;

变为----

 private AtomicInteger count = new AtomicInteger();

 count.incrementAndGet();

return this.count.get();

另外核心源码：定义为final----不难理解了吧

 public final int getAndIncrement() {
        for (;;) {
            int current = get();
            int next = current + 1;
            if (compareAndSet(current, next))
                return current;
        }
    }