一、原⼦性指的是什么意思
不和分割，完整性，也即某个线程正则做某个具体业务时，中间不可以被加塞或者被分割。
需要 整体完成，要么同时成功，要么同时失败。
package thread;import java.util.concurrent.TimeUnit;/*** volitale关键字是Java提供的⼀种轻量级同步机制。* 它能够保证可⻅性和有序性* 但是不能保证原⼦性* 禁⽌指令重排*/class MyData2 {// int number = 0;volatile int number = 0;//此时number前⾯已经加了volatile，但是不保证原⼦性public void addPlusPlus(){number++;}}public class VolatileDemo2 {public static void main(String[] args) {atomicDemo();}/*** 创建20线程，每个线程执行1000次的number++操作*/private static void atomicDemo() {System.out.println("原⼦性测试");MyData2 myData = new MyData2();// 创建20线程for (int i = 1; i <= 20; i++) {new Thread(()->{// 每个线程执行1000次的number++操作for (int j = 0; j <1000 ; j++) {// 最终number应该为 number = 20 * 1000 = 20000myData.addPlusPlus();}},String.valueOf(i)).start();}// main线程，等待20个线程执行完毕后，打印number变量的值// 可以发现当前线程组包含：main和Monitor Ctrl-Break// IntelliJ IDEA执行用户代码的时候，实际是通过反射方式去调用，而与此同时会创建一个Monitor Ctrl-Break 用于监控目的。while (Thread.activeCount() > 2){// main线程，执行礼让操作Thread.yield();}System.out.println(Thread.currentThread().getName()+"\t int类型最终 number值: "+myData.number);}}
结果：
可⻅，由于 volatile 不能保证原⼦性，出现了线程重复写的问题，最终结果⽐20000⼩。
⽽ AtomicInteger 可以保证原⼦性。
Java线程中的Thread.yield()方法，译为线程让步。
顾名思义，就是说当一个线程使用了这个方法之后，它就会把自己CPU执行的时间让掉，
让自己或者其它的线程运行，注意是让自己或者其他线程运行，并不是单纯的让给其他线程。
yield()的作用是让步。它能让当前线程由“运行状态”进入到“就绪状态”，从而让其它具有相同优先级的等待线程获取执行权；
但是，并不能保证在当前线程调用yield()之后，其它具有相同优先级的线程就一定能获得执行权；也有可能是当前线程又进入到“运行状态”继续运行！
举个例子：一帮朋友在排队上公交车，轮到Yield的时候，他突然说：我不想先上去了，咱们大家来竞赛上公交车。然后所有人就一块冲向公交车，
有可能是其他人先上车了，也有可能是Yield先上车了。
但是线程是有优先级的，优先级越高的人，就一定能第一个上车吗？这是不一定的，优先级高的人仅仅只是第一个上车的概率大了一点而已，
最终第一个上车的，也有可能是优先级最低的人。并且所谓的优先级执行，是在大量执行次数中才能体现出来的。
/java-spring/p/8309931.html
二、volatile并不能保证操作的原⼦性
这是因为，⽐如⼀条number++的操作，会形成3条指令。
javap -c 包名.类名
public void addPlusPlus(); Code:0: aload_0 1: dup 2: getfield #2 // Field number:I //读5: iconst_1//++常量16: iadd //加操作7: putfield #2 // Field number:I //写操作10: return
假设有3个线程，分别执⾏number++，都先从主内存中拿到最开始的值，number=0，然后三个线程分 别进⾏操作。
假设线程0执⾏完毕，number=1，也⽴刻通知到了其它线程，但是此时线程1、2已经拿 到了number=0，所以结果就是写覆盖，线程1、2将number变成1。
解决的⽅式就是：
1. 对 addPlusPlus() ⽅法加锁。
2. 使⽤ java.util.concurrent.AtomicInteger 类。
package thread;import java.util.concurrent.atomic.AtomicInteger;class MyData3{//int number=0;volatile int number=0;//此时number前⾯已经加了volatile，但是不保证原⼦性public void addPlusPlus(){number++;}AtomicInteger atomicInteger = new AtomicInteger();public void addAtomic(){atomicInteger.getAndIncrement();}}public class VolatileDemo3 {public static void main(String[] args) {//volatileVisibilityDemo();atomicDemo();}private static void atomicDemo() {System.out.println("原⼦性测试");MyData3 myData=new MyData3();for (int i = 1; i <= 20; i++) {new Thread(()->{for (int j = 0; j <1000 ; j++) {myData.addPlusPlus();myData.addAtomic();}},String.valueOf(i)).start();}while (Thread.activeCount()>2){Thread.yield();}System.out.println(Thread.currentThread().getName()+"\t int类型最终 number值: "+myData.number);System.out.println(Thread.currentThread().getName()+"\t AtomicInteger类型最终number值: "+myData.atomicInteger);}}
结果：
由于 volatile 不能保证原⼦性，出现了线程重复写的问题，最终结果⽐20000⼩。
⽽ AtomicInteger 可以保证原⼦性。
