解析并发问题的非原子性问题（Atomic原子类）

1. 不使用Atomic原子类：

原子:不可分割 100行代码是一个原子,线程执行100行代码不可以分开执行,要么都执行,要都不执行

需求: 1.定义多线程共享的静态变量money 2.Thread-0线程把money的值增加10000 3.main线程把money的值增加10000 4.查看money的最终结果

public class MyThread extends Thread{
    //1.定义多线程共享的静态变量money
    public static int money = 0;

    @Override
    public void run() {
        System.out.println("Thread-0线程开始执行,修改变量money的值!");
        //2.Thread-0线程把money的值增加10000
        for (int i = 0; i < 10000; i++) {
            money++;//0==>1==>2==>3==>...==>10000
        }
        System.out.println("Thread-0线程执行线程任务结束!");
    }
}

public class Demo01Atom {
    public static void main(String[] args) throws InterruptedException {
        //创建MyThread对象
        MyThread mt = new MyThread();
        //调用start方法,开启新的线程,执行run方法
        mt.start();

        System.out.println("main线程在开启Thread-0线程之后,继续执行main方法中的代码!");
        System.out.println("main线程修改变量money的值!");
        //3.main线程把money的值增加10000
        for (int i = 0; i < 10000; i++) {
            MyThread.money++;
        }
        System.out.println("main线程修改变量money的值结束!");
        System.out.println("main线程睡眠2秒钟,等待Thread-0线程执行完毕,在统计结果!");
        Thread.sleep(2000);
        //4.查看money的最终结果
        System.out.println("money的最终的结果是:"+MyThread.money);
    }
}

执行结果：

main线程在开启Thread-0线程之后,继续执行main方法中的代码!
main线程修改变量money的值!
Thread-0线程开始执行,修改变量money的值!
main线程修改变量money的值结束!
main线程睡眠2秒钟,等待Thread-0线程执行完毕,在统计结果!
Thread-0线程执行线程任务结束!
money的最终的结果是:14338

修改第二段代码：

添加thread.sleep(10)；

package com.allen.thread1;

public class Demo01Atom {
    public static void main(String[] args) throws InterruptedException {
        //创建MyThread对象
        MyThread mt = new MyThread();
        //调用start方法,开启新的线程,执行run方法
        mt.start();

        Thread.sleep(10);
        System.out.println("main线程在开启Thread-0线程之后,继续执行main方法中的代码!");
        System.out.println("main线程修改变量money的值!");
        //3.main线程把money的值增加10000
        for (int i = 0; i < 10000; i++) {
            MyThread.money++;
        }
        System.out.println("main线程修改变量money的值结束!");
        System.out.println("main线程睡眠2秒钟,等待Thread-0线程执行完毕,在统计结果!");
        Thread.sleep(2000);
        //4.查看money的最终结果
        System.out.println("money的最终的结果是:"+MyThread.money);
    }
}

Thread-0线程开始执行,修改变量money的值!
Thread-0线程执行线程任务结束!
main线程在开启Thread-0线程之后,继续执行main方法中的代码!
main线程修改变量money的值!
main线程修改变量money的值结束!
main线程睡眠2秒钟,等待Thread-0线程执行完毕,在统计结果!
money的最终的结果是:20000

结果始终是20000，是因为每次都是Thread0先执行完毕，然后再执行main线程。

2. 使用Atomic原子类：

package com.allen.thread;

/**
 * @author ：jhys
 * @date ：Created in 2021/7/14 15:45
 * @Description ：
 */
public class Demo {
    public static void main(String[] args) throws Exception {

        MyThread myThread = new MyThread();

        myThread.start();

        System.out.println("main线程在开启Thread-0线程之后,继续执行main方法中的代码!");
        System.out.println("main线程修改变量money的值!");

        //3.main线程把money的值增加10000
        for (int i = 0; i < 10000; i++) {
            MyThread.money.incrementAndGet();
        }
        System.out.println("main线程修改变量money的值结束!");
        System.out.println("main线程睡眠2秒钟,等待Thread-0线程执行完毕,在统计结果!");
        Thread.sleep(2000);
        //4.查看money的最终结果
        System.out.println("money的最终的结果是:"+MyThread.money);
    }
}

package com.allen.thread;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author ：jhys
 * @date ：Created in 2021/7/14 15:43
 * @Description ：
 */
public class MyThread extends Thread{

    public static AtomicInteger money = new AtomicInteger(0);

    @Override
    public void run() {
        System.out.println("Thread-0线程开始执行,修改变量money的值!");
        for (int i = 0; i < 10000; i++) {
            money.incrementAndGet();
        }
        System.out.println("Thread-0线程执行线程任务结束!");
    }
}

main线程在开启Thread-0线程之后,继续执行main方法中的代码!
main线程修改变量money的值!
Thread-0线程开始执行,修改变量money的值!
Thread-0线程执行线程任务结束!
main线程修改变量money的值结束!
main线程睡眠2秒钟,等待Thread-0线程执行完毕,在统计结果!
money的最终的结果是:20000

结果始终是20000，可见Atomic原子类的incrementAndGet（）方法是原子性操作，可以保证原子性。

总结：

概述：所谓的原子性是指在一次操作或者多次操作中，要么所有的操作全部都得到了执行并且不会受到任何因素的干扰而中断，要么所有的操作都不执行，

多个操作是一个不可以分割的整体(原子)。

比如：从张三的账户给李四的账户转1000元，这个动作将包含两个基本的操作：从张三的账户扣除1000元，给李四的账户增加1000元。这两个操作必须符合原子性的要求，

要么都成功要么都失败。

1.原子类概述

概述：java从JDK1.5开始提供了java.util.concurrent.atomic包(简称Atomic包)，这个包中的原子操作类提供了一种用法简单，性能高效，线程安全地更新一个变量的方式。

1). java.util.concurrent.atomic.AtomicInteger：对int变量进行原子操作的类。

2). java.util.concurrent.atomic.AtomicLong：对long变量进行原子操作的类。

3). java.util.concurrent.atomic.AtomicBoolean：对boolean变量进行原子操作的类。

这些类可以保证对“某种类型的变量”原子操作，多线程、高并发的环境下，就可以保证对变量访问的有序性，从而保证最终的结果是正确的。

AtomicInteger原子型Integer，可以实现原子更新操作

构造方法:
public AtomicInteger()：                       初始化一个默认值为0的原子型Integer
public AtomicInteger(int initialValue)： 初始化一个指定值的原子型Integer
成员方法:
int get():                                 获取AtomicInteger对象中存储的int值
int getAndIncrement(): i++                  以原子方式将当前值加1，注意，这里返回的是自增前的值。
int incrementAndGet(): ++i                 以原子方式将当前值加1，注意，这里返回的是自增后的值。
int addAndGet(int data):                 以原子方式将输入的数值与实例中的值（AtomicInteger里的value）相加，并返回结果。
int getAndSet(int value):                以原子方式设置为newValue的值，并返回旧值。

AtomicInteger解决变量的原子性(可见性、有序性)(重点)，参照上述例子

AtomicInteger的原理_CAS机制（乐观锁）