CAS(Compare And Swap)原子操作（1）

原子操作

原子操作是指不会被线程调度机制打断的操作；这种操作一旦开始，就一直运行到结束，中间不会出现切换到其他线程的情况。通俗的讲：要么不做，要做我就要做完整个任务。

应用场景

1. 在多线程共同运行执行同个代码块时，如果遇到多线程同时写入就会导致出现最后值与预期值不符的现象。
2. volatile修饰变量只保证可见性和有序性，无法保证原子性的保护。

CAS的简单介绍

atomic包

1. CAS支持的基本类型：AtomicInteger、AtomicBoolean、AtomicLong
2. CAS支持的数组类型：AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray（对象的引用数组）
3. AtomicIntegerFieldUpdater、AtomicLongFieldUpdater、AtomicReferenceFieldUpdater。这里主要是处理CAS从A -> B -> A的问题，如果是上面1、2方法中类型是无法感知里面的value发生了变化，所以xxxxFieldUpdater的诞生是专门用于处理这种ABA情况。
   还有一些不常用的我就不罗列出来了。自己可以翻墙看google官网

AtomicInteger

简单入手AtomicInteger,从代码和demo上理解CAS的原理。

CountDownLatch并发线程操作

1. CountDownLatch是一个计数器，所有的操作都是原子操作，意味着它内部实现也是通过CAS实现的。当然主要这里只简单介绍它的用法。当CountDownLatch的value不是0的时候，任何任务调用CountDownLatch.await()方法都会阻塞等待（AQS队列），直到CountDownLatch的value减成0才会被唤醒。

模拟多线程时间片轮转

1. 首先生成10个线程用来模拟多线程调度。
2. 使用volatile变量作为对比结果A。
3. 用AtomicInteger变量作为对比结果B。

package cn.magic.test

import org.apache.tools.ant.taskdefs.Sleep
import org.junit.Assert
import org.junit.Test

import org.junit.Assert.*
import org.junit.Before
import java.util.concurrent.CountDownLatch
import java.util.concurrent.atomic.AtomicInteger

/**
 * Example local unit test, which will execute on the development machine (host).
 *
 * See [testing documentation](http://d.android.com/tools/testing).
 */
class ExampleUnitTest {
    @Volatile
    var count: Int = 0

    lateinit var count1: AtomicInteger

    val MAX_THREAD_NUMBER = 10

    val cutDowm: CountDownLatch = CountDownLatch(MAX_THREAD_NUMBER)

    @Before
    fun before() {
        count1 = AtomicInteger(0)
    }

    @Test
    fun addition_isCorrect() {
        val threads = arrayOfNulls<Thread>(MAX_THREAD_NUMBER)
        for (i in 0 until MAX_THREAD_NUMBER) {
            threads[i] = Thread(Runnable {
                for (j in 0 until 1000) {
                    increase()
                }
                cutDowm.countDown()
            })
            threads[i]?.start()
        }
        //等10个线程都运行结束后再输出最后结果
        cutDowm.await()
        Assert.assertEquals(10000, count)
//        Assert.assertEquals(10000, count1.get())
    }

    fun increase() {
        count++
        count1.getAndIncrement()
    }
}

volatile变量的结果

1. 出现这个结果的原因和JVM的内存模式和字节码执行有关系。Jvm内存模型中12.3.6先行发生原则中有相关讲解。
   通俗的将就是volatile修饰的只能保证可见性与有序性，在你自增字节码执行时，另外个线程把内存的value从A -> B了，但是这时候已经过了读取内存中的value值的时候，不会重新再去内存中获取一次，导致字节码执行完成后就会丢失A -> B的操作。

   
   volatile修饰的变量

CAS变量的结果

1. 那么纠结AtomicInteger内部如何实现的呢？下一章节单独从其源码进行分析

   
   CAS变量