多线程05-LockSupport--JMM内存模型(三大特性&happens-before原则)

LockSupport是用来创建锁和其他同步类的基本线程阻塞原语。
LockSupport中的park() 和 unpark() 的作用分别是阻塞线程和解除阻塞线程

1.三种让线程等待和唤醒的方法：

1.使用Object中的wait()方法让线程等待，使用Object中的notify()方法唤醒线程
2.使用JUC包中Condition的await()方法让线程等待，使用signal()方法唤醒线程
3.LockSupport类可以阻塞当前线程以及唤醒指定被阻塞的线程

1.1Object中的wait()方法让线程等待：

static Object objectLock =new Object();
    public static void main(String[] args) {

        new Thread(()->{
           synchronized (objectLock){
               System.out.println(Thread.currentThread().getName()+" com in--------");
               try {
                   objectLock.wait();
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               System.out.println(Thread.currentThread().getName()+"  被唤醒");
           }
        },"t1").start();

        try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }

        new Thread(()->{
            synchronized (objectLock){
                objectLock.notify();
                System.out.println(Thread.currentThread().getName()+" 发出通知");

            }
                },"t2").start();
    }

带来的问题：

1.synchronized、wait、notify三者必须同时存在，
2.wait不能落后于notify执行

1.2：JUC包中Condition的await()方法让线程等待：

锁绑定多个Condition：2个以上线程之间按顺序调用，并要求精确唤醒指定线程。此处不写这个案例了

 static Lock lock =new ReentrantLock();
    static Condition condition =lock.newCondition();
    public static void main(String[] args) {
        new Thread(()->{
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() +"  come in");
                condition.await();
                System.out.println(Thread.currentThread().getName() +"  被唤醒");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                lock.unlock();
            }

                },"t1").start();

        new Thread(()->{
            lock.lock();
            try {
                condition.signal();
                System.out.println(Thread.currentThread().getName() +" 发出通知");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        },"t2").start();

    }

结果：

t1  come in
t2 发出通知
t1  被唤醒

结论：

线程先要获得并持有锁，必须在锁块(synchronized或lock)中，必须要先等待后唤醒，线程才能够被唤醒

1.3 LockSuport 的park&unpark(thread)

LockSupport类使用了一种名为Permit（许可）的概念来做到阻塞和唤醒线程的功能， 每个线程都有一个许可(permit)，
permit只有两个值1和零，默认是零。
可以把许可看成是一种(0,1)信号量（Semaphore），但与 Semaphore 不同的是，许可的累加上限是1。

public static void main(String[] args) {

        Thread t1 = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() +"  come in");
            LockSupport.park();
            System.out.println(Thread.currentThread().getName() +"  被唤醒");
        }, "t1");
        t1.start();

        new Thread(()->{
            LockSupport.unpark(t1);
            System.out.println(Thread.currentThread().getName() +" 发出通知");
                },"t2").start();
    }

结果：

t1  come in
t2 发出通知
t1  被唤醒

优势：无锁块要求+唤醒等待顺序无要求

1.3.1：park&unpark实现t1线程多次阻塞，咋办：n

那就新开n个线程，t1线程再加n个 LockSupport.park()和其他线程数对应。

2.JMM

三大特性：可见性。原子性，有序性(禁止指令重排)

2.1可见性

是指当一个线程修改了某一个共享变量的值，其他线程是否能够立即知道该变更 ，JMM规定了所有的变量都存储在主内存中

Java中普通的共享变量不保证可见性，因为数据修改被写入内存的时机是不确定的，多线程并发下很可能出现"脏读"，所以每个线程都有自己的工作内存，线程自己的工作内存中保存了该线程使到的变量的主内存副本拷贝，线程对变量的所有操作（读取，赋值等 ）都必需在线程自己的工作内存中进行，而不能够直接读写主内存中的变量。不同线程之间也无法直接访问对方工作内存中的变量，线程间变量值的传递均需要通过主内存来完成

若没有可见性保证，则线程脏读：

1.主内存中有变量 x，初始值为 0
2.线程 A 要将 x 加 1，先将 x=0 拷贝到自己的私有内存中，然后更新 x 的值
3.线程 A 将更新后的 x 值回刷到主内存的时间是不固定的
4.刚好在线程 A 没有回刷 x 到主内存时，线程 B 同样从主内存中读取 x，此时为 0，和线程 A 一样的操作，最后期盼的 x=2 就会变成 x=1

2.2 原子性

指一个操作是不可中断的，即多线程环境下，操作不能被其他线程干扰

2.3有序性

为了提供性能，编译器和处理器通常会对指令序列进行重新排序。
指令重排可以保证串行语义一致，但没有义务保证多线程间的语义也一致，即可能产生"脏读"，简单说，
两行以上不相干的代码在执行的时候有可能先执行的不是第一条，不见得是从上到下顺序执行，执行顺序会被优化。

单线程环境里面确保程序最终执行结果和代码顺序执行的结果一致。
处理器在进行重排序时必须考虑指令之间的数据依赖性
多线程环境中线程交替执行,由于编译器优化重排的存在，两个线程中使用的变量能否保证一致性是无法确定的,结果无法预测

2.3.1一个小例子：

public void mySort()
{
int x = 11; //语句1
int y = 12; //语句2
x = x + 5; //语句3
y = x * x; //语句4
}
语句执行顺序：
1234
2134
1324
问：执行顺序可以为4123吗？no，没考虑数据依赖性。

2.4 happens-before原则：

在JMM中，
如果一个操作执行的结果需要对另一个操作可见性
或者 代码重排序，那么这两个操作之间必须存在happens-before关系

2.4.1先行发生原则说明：

如果Java内存模型中所有的有序性都仅靠volatile和synchronized来完成，那么有很多操作都将会变得非常啰嗦，
但是我们在编写Java并发代码的时候并没有察觉到这一点。

我们没有时时、处处、次次，添加volatile和synchronized来完成程序，这是因为Java语言中JMM原则下有一个“先行发生”(Happens-Before)的原则限制和规矩

这个原则非常重要：
它是判断数据是否存在竞争，线程是否安全的非常有用的手段。依赖这个原则，我们可以通过几条简单规则一揽子解决并发环境下两个操作之间是否可能存在冲突的所有问题，而不需要陷入Java内存模型苦涩难懂的底层编译原理之中。

2.4.2 happens-before总原则：

2.4.2.1：

如果一个操作happens-before另一个操作，那么第一个操作的执行结果将对第二个操作可见，而且第一个操作的执行顺序排在第二个操作之前。

2.4.2.2：

两个操作之间存在happens-before关系，并不意味着一定要按照happens-before原则制定的顺序来执行。
如果重排序之后的执行结果与按照happens-before关系来执行的结果一致，那么这种重排序并不非法。(1+2和2+1)

2.4.3happens-before八条规则：

单线程的：

1.次序规则：
一个线程内，按照代码顺序，写在前面的操作先行发生于写在后面的操作；
前一个操作的结果可以被后续的操作获取。也就是前面一个操作把变量X赋值为1，那后面一个操作肯定能知道X已经变成了1。

2.锁定规则：
一个unLock操作先行发生于后面((这里的“后面”是指时间上的先后))对同一个锁的lock操作；

3.volatile变量规则：
对一个volatile变量的写操作先行发生于后面对这个变量的读操作，
前面的写对后面的读是可见的，这里的“后面”同样是指时间上的先后。

4.传递规则
如果操作A先行发生于操作B，而操作B又先行发生于操作C，则可以得出操作A先行发生于操作C；

多线程的：

5.线程启动规则
Thread对象的start()方法先行发生于此线程的每一个动作

6.线程中断规则
对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生；可以通过Thread.interrupted()检测到是否发生中断

7.线程终止规则
线程终止一定是最后执行的，线程先出生再执行任务最后死掉

8.对象终结规则
对象没有完成初始化之前，是不能调用finalized()方法的

这八条原则简直是听我一席话，如同听p话了属实是。。。。。。。。。

案例：

假设存在线程A和B，线程A先（时间上的先后）调用了setValue(1)，然后线程B调用了同一个对象的getValue()，那么线程B收到的返回值
是什么？ 答：无法确定

我们就这段简单的代码一次分析happens-before的规则（规则5、6、7、8 可以忽略，因为他们和这段代码毫无关系）：
1 由于两个方法是由不同的线程调用，不在同一个线程中，所以肯定不满足程序次序规则；
2 两个方法都没有使用锁，所以不满足锁定规则；
3 变量不是用volatile修饰的，所以volatile变量规则不满足；
4 传递规则肯定不满足；

所以就得用多线程下的锁机制