多线程的应用与原理分析9（原子操作）

- 日理万妓 2022-03-22 02:18 264阅读 0赞

> **文章最前**： 我是Octopus，这个名字来源于我的中文名--章鱼；我热爱编程、热爱算法、热爱开源。所有源码在我的个人[github][] ；这博客是记录我学习的点点滴滴，如果您对 Python、Java、AI、算法有兴趣，可以关注我的动态，一起学习，共同进步。

**相关文章：**

1.  [多线程的应用与原理分析1][1]
2.  [多线程的应用与原理分析2（线程的状态）][2]
3.  [多线程的应用与原理分析3（原子性、可见性、有序性）][3]
4.  [多线程的应用与原理分析4（synchronized）][4_synchronized]
5.  [多线程的应用与原理分析5（ReentrantLock）][5_ReentrantLock]
6.  [多线程的应用与原理分析6（ReentrantLock）][6_ReentrantLock]
7.  [多线程的应用与原理分析7（Condition）][7_Condition]
8.  [多线程的应用与原理分析8（countdownlatch）][8_countdownlatch]
9.  [多线程的应用与原理分析9（原子操作）][9]
10. [多线程的应用与原理分析10（Semaphore）][10_Semaphore]
11. [多线程的应用与原理分析11（线程池）][11]

--------------------

**原子操作**  
         当在多线程情况下，同时更新一个共享变量，由于我们前面讲过的原子性问题，可能得不到预期的结果。如果要达到期望的结果，可以通过synchronized来加锁解决，因为synchronized会保证多线程对共享变量的访问进行排队。  
        在Java5以后，提供了原子操作类，这些原子操作类提供了一种简单、高效以及线程安全的更新操作。而由于变量的类型很多，所以Atomic一共提供了12个类分别对应四种类型的原子更新操作，基本类型、数组类型、引用类型、属性类型。  
基本类型：AtomicBoolean、AtomicInteger、AtomicLong  
数组类型：AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray  
引用类型：AtomicReference、AtomicReferenceFieldUpdater、AtomicMarkableReference  
字段类型：AtomicIntegerFieldUpdater、AtomicLongFieldUpdater、AtomicStampedReference  
**Atomic原子操作的使用**

package lock;
    
    import java.util.concurrent.atomic.AtomicInteger;
    
    /**
     * @author zhangyu
     * @version V1.0
     * @ClassName: AtomicIntegerDemo
     * @Description: TOTO
     * @date 2019/1/25 14:13
     **/
    
    
    public class AtomicIntegerDemo {
        private static AtomicInteger count = new AtomicInteger(0);
    
        public static synchronized void incr() {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            count.getAndIncrement();
        }
    
        public static void main(String[] args) throws InterruptedException {
            for (int i = 0; i < 1000; i++) {
                new Thread(() -> {
                    AtomicIntegerDemo.incr();
                }).start();
            }
            Thread.sleep(4000);
            System.out.println(count.get());
        }
    }

**AtomicInteger实现原理**  
         由于所有的原子操作类都是大同小异的，所以我们只分析其中一个原子操作类

public final int getAndIncrement() {
         return unsafe.getAndAddInt(this, valueOffset, 1);
    }

大家又会发现一些熟悉的东西，就是unsafe。调用unsafe类中的getAndAddInt方法，这个方法如下：

public final int getAndAddInt(Object var1, long var2, int var4) {
       int var5;
       do {
          var5 = this.getIntVolatile(var1, var2);// 方法获取对象中offset偏移地址对应的整型field的 
        值
       } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
         return var5;
    }

通过循环以及cas的方式实现原子更新，从而达到在多线程情况下仍然能够保证原子性的目的。大家会发现，只要基本的东西搞明白以后，剩下的都比较容易理解了。

[github]: https://github.com/zhangyu345293721
[1]: https://blog.csdn.net/zy345293721/article/details/86565631
[2]: https://blog.csdn.net/zy345293721/article/details/86583663
[3]: https://blog.csdn.net/zy345293721/article/details/86596268
[4_synchronized]: https://blog.csdn.net/zy345293721/article/details/86607632
[5_ReentrantLock]: https://blog.csdn.net/zy345293721/article/details/86617801
[6_ReentrantLock]: https://blog.csdn.net/zy345293721/article/details/86621392
[7_Condition]: https://blog.csdn.net/zy345293721/article/details/86622891
[8_countdownlatch]: https://blog.csdn.net/zy345293721/article/details/86636846
[9]: https://blog.csdn.net/zy345293721/article/details/86645245
[10_Semaphore]: https://blog.csdn.net/zy345293721/article/details/86644996
[11]: https://blog.csdn.net/zy345293721/article/details/86646019