1.volatile

1、概念：是java虚拟机提供的轻量级的同步机制
2、特性： 
        - 保证可见性
        - 不保证原子性
        - 禁止指令重排序

2.JMM（java内存模型）

1、概念：是一个抽象的概念并不真实存在，描述的是一组规则或规范，通过这组规范定义了程序中各个变量（等）访问方式。
2、JMM同步规定
    - 线程解锁前，必须把共享变量的值刷新回主内存
    - 线程加锁前，必须读取主内存的最新值到自己的工作内存
    - 
3、特性：
    - 可见性
    - 原子性（不可分割，完整性，也即某个线程正在做某个具体业务时，中间不可以加塞或分割。需要整体完整要么同时成功，要么同时失败。）
    - 有序性

3.volatile代码可见性

class MyData{
  int number = 0;
  public void addT60{
    this.number = 60;
  }
}

public class VolatileDemo{
  public static void main(String[] args){
    MyData mydata = new MyData();
    new Thread(()->{
      System.out.println(Thread.currentThread().getName()+"\t come in");
      TimeUnit.SECONDS.sleep(3);
      myDate.addT60();
      System.out.println(Thread.currentThread().getName()+"\t update number value:"+myDate.number);      
    }  
    while(myData.number == 0){
    //main线程就一直再这里等待循环，知道number值不等于零。
    }
     System.out.println(Thread.currentThread().getName()+"\t mission is over");      
  }
}

4.volatile代码不保证原子性

class MyData{
  int number = 0;
  public void addT60{
    this.number = 60;
  }
  public void addPlusPlus(){
    number++; 
  }
}

public class VolatileDemo{
  public static void main(String[] args){
    MyData mydata = new MyData();
    for(int i = 1; i <= 20; i++){
      new Thread(()->{
         for(int j = 1; j <= 1000; j++){
            myData.addPlusPlus();
          }
      },String.values(i)).start(); 
    }
    //需要等待上面的20个线程都全部计算完成后，再用main线程取得最终的结果值看是多少？
    while(Thread.activeCount() > 2){
      Thread.yield();
    }
     System.out.println(Thread.currentThread().getName()+"\t finally number value :"+myData.number);      
  }
}

5.解决原子性

1、加sync(不建议)
2、用juc下AtomicInteger

6.

1、单线程环境里面确保程序最终执行结果和代码顺序执行的结果一直。（即不会指令重排）
2、多线程环境中线程交替执行，由于编译器优化重排的存在，两个线程中使用的变量能否保证一致性是无法确定的，结果无法预测。 

7.CAS思想（自旋）

1、概念：比较并交换 ===> compareAndSet
2、底层原理：UnSafe是CAS的核心类，由于Java方法无法直接访问底层系统，需要通过本地（native）方法访问，Unsafe相当于一个后门，基于该类可以之季节操作特定的内存数据。Unsafe类存在于sun.misc包中，其内部方法操作可以像C的指针一样直接操作内存，因为Java中CAS操作的执行依赖于Unsafe类的方法。
3、unsafe.getAndAddInt()

8.CAS缺点

1、循环时间长开销大
2、只能保证一个共享变量的原子性操作
3、ABA问题

9.ABA

1、概念：狸猫换太子
2、原子引用（AtomicReference<T>）
3、解决ABA问题，时间戳引用AtomicStampedReference<T>

10.ConcurrentModifiationException

1、导致原因：并发争抢修改导致。
2、解决方法
      - Vector<>();
      - Collections.synchronizedList(new ArrayList());
      - new CopyOnWriteArrayList();
3、HashSet底层数据结构为HashMap<>
    

11.锁

1、公平和非公平锁
      - 公平锁：排队 
      - 非公平锁：插队，不成功则排队。优点：在意吞吐量比公平锁大。
2、synchronized为非公平锁。
3、可重入锁（又名递归锁）
      - 指的是同一线程外层函数获得锁之后，内层帝国函数仍然能获取该锁的代码，在同一线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。
即线程可以进入人后一个它已经拥有的锁所同步的代码块。
      - 作用：防止死锁
4、自旋锁
      - 是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式获取锁，这样的好处是减少线程上下文切换的消耗，缺点是循环会消耗cpu
    -   好处：循环比较获取直到成功为止，没有类似wait的阻塞。
5、独占锁，共享锁  ReentrantReadWriteLock