1、synchronized 实现原理

 在Java的对象头里面， 有一块数据叫Mark Word。在64位机器上， Mark Word是8字节（64位）的， 这64位中有两个重要字段：锁标志位和占用锁的thread ID。

2、wait 和 notify

  生产者 - 消费者模型

  生产者-消费者模型是一个常见的多线程编程模型。

                                        生产者-消费者模型

一个内存队列，多个生产者线程从我那个内存队列数据；多个消费者线程从内存队列中取数据要实现这样一个编程模型， 需要做下面几件事情：

1. 内存队列本身要加锁，才能实现线程安全。
   
2. 阻塞，当内存队列满了，生产者放不进去时，会被阻塞；当内存队列是空的时候，消费者无事可做，会被阻塞。
   
3. 双向管理。消费者被阻塞之后，生产者放入新数据，要notify(）消费者；反之，生产者被阻塞之后， 消费者消费了数据，要notify（）生产者。
   第一件事必须要做，第二件事和第三件事不一定要做。
   
   如何阻塞？
   方法1：线程自己阻塞自己，也就是生产者、消费者线程各自调用wait()和notify().
   方法2：用一个阻塞队列，当取不到或者放不进去数据的时候，入队/出队函数本身就是阻塞的。
   
   如何双向通知？
   方法1：wait()和notify()机制。
   方法2：Condition机制
   
   

3、为什么必须和synchronized一起使用

    开两个线程，线程A调用f1()，线程B调用f2()。两个线程之间要通信，对于同一个对象来说，一个线程调用该对象wait()，例外一个线程调用该对象的notify()，该对象本身需要同步！所以，在调用wait()、notify()之前，要先通过synchronized关键字同步给对象，也就是给对象加锁。

4、为什么wait()的时候必须释放锁

    wait()内部伪代码

1、synchronized 实现原理
  在Java的对象头里面， 有一块数据叫Mark Word。在64位机器上， Mark Word是8字节（64位）的， 这64位中有两个重要字段：锁标志位和占用锁的thread ID。
2、wait 和 notify
   生产者 - 消费者模型
   生产者-消费者模型是一个常见的多线程编程模型。
图片
                                         生产者-消费者模型
一个内存队列，多个生产者线程从我那个内存队列数据；多个消费者线程从内存队列中取数据要实现这样一个编程模型， 需要做下面几件事情：
内存队列本身要加锁，才能实现线程安全。
阻塞，当内存队列满了，生产者放不进去时，会被阻塞；当内存队列是空的时候，消费者无事可做，会被阻塞。
双向管理。消费者被阻塞之后，生产者放入新数据，要notify(）消费者；反之，生产者被阻塞之后， 消费者消费了数据，要notify（）生产者。
第一件事必须要做，第二件事和第三件事不一定要做。
如何阻塞？
方法1：线程自己阻塞自己，也就是生产者、消费者线程各自调用wait()和notify().
方法2：用一个阻塞队列，当取不到或者放不进去数据的时候，入队/出队函数本身就是阻塞的。
如何双向通知？
方法1：wait()和notify()机制。
方法2：Condition机制
3、为什么必须和synchronized一起使用
     开两个线程，线程A调用f1()，线程B调用f2()。两个线程之间要通信，对于同一个对象来说，一个线程调用该对象wait()，例外一个线程调用该对象的notify()，该对象本身需要同步！所以，在调用wait()、notify()之前，要先通过synchronized关键字同步给对象，也就是给对象加锁。
4、为什么wait()的时候必须释放锁
     wait()内部伪代码

    5、wait() 和 notify() 的问题

  生产者本来只想通知消费者，但它把其他的生产者也通知了；消费者本来只想通知生产者，但它把其他的消费者也通知了。原因是wait()和notify()作用的对象和synchronized作用的对象是同一个，每个对象没有区分标识。精确唤醒我们可以用Condition来实现。

6、volatile 关键字

    volatile 三重功效

•     64位写入的原子性
  
•     内存可见性
  
•     禁止重排序
  

 6.1  64位写入的原子性（Half Write）

     多线程场景下，线程A调用set(100)，线程B调用get()，在某些场景下，返回值可能不是100

     这是因为JVM规范没有要求64位的long或者double的写入是原子的。在32位的机器上，一个64位变量的写入可能被拆分成两个32位的写操作来执行。这样一来，读取线程就可能读到一半的值。

解决方法是：在long 前面加上volatile 关键字

 6.2  内存可见性

     不仅64位，32位或者位数更小的赋值和取值操作，其实也有问题。比如一个线程修改变量值为true之后，另外一个线程去读，读到的是false，但是之后能读到true。也就是最终一致性，不是强一致性。

所以，内存可见性，指的是写完之后立即对其他线程可见，它的反面不是不可见，而是稍后才能看见。

解决这个问题很容易，给变量加上volatile关键字即可

 6.3  重排序：DCL问题

  单例模式的线程安全，常见的写法为DCL(Double Checking Locking)

public class Sington{
     private static Sington instance;
     private static Sington getInstance{
         if(instance == null){
             synchronized(Sington.class){
                if(instance == null){
                     instance = new Instance();
                }
             }
         }
         return instance;
     }
}

上述的 instance = new Instance()代码有问题：其底册会分为三个操作：

 1、分配一块内存

 2、在内存上初始化成员变量

 3、把instance 引用指向内存

操作2和3 可能重排序。即先把instance指向内存，再初始化成员变量，因为二者先后没有依赖关系。此时，另一个线程可能拿到一个未完全初始化的对象，直接去访问里面的成员变量，就可能出错。这就是典型的“构造函数溢出”问题。

解决方法：为instance变量加上volatile修饰。