java之原子性

清疚 2022-07-20 15:03 226阅读 0赞

**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;
            }
        }