（二）多线程notify()是唤醒线程顺序：有序的！有序的！

多线程notify()是有序唤醒线程的！！有序的！！有序的！！

重要的事情说三遍 就是有序的唤醒等待的线程的

之前网上有很多说notify是随时唤醒线程的 是错的
这里我们用两个例子来举证一下 ，这种方式比源码来的简单
当然如果不够详细的话 大家可以去研究一下 wait和notify的源码，这里我就不贴出来了

package com.zmkj.admin.test;

import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * 研究 notify 唤醒线程的顺序  有序？随机？
 *
 * @author sunminghao
 */
public class NotifySequence {

    //等待列表, 用来记录等待的顺序
    private static List<String> waitList = new LinkedList<>();
    //唤醒列表, 用来唤醒的顺序
    private static List<String> notifyList = new LinkedList<>();

    private static Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
        //创建10个线程
        for(int i=0;i<10;i++){
            String threadName = Integer.toString(i);
            new Thread(() -> {
                synchronized (lock) {
                    String cthreadName = Thread.currentThread().getName();
                    System.out.println("线程 ["+cthreadName+"] 正在等待.");
                    waitList.add(cthreadName);
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("线程 ["+cthreadName+"] 被唤醒了.");
                    notifyList.add(cthreadName);
                }
            },threadName).start();

            TimeUnit.MILLISECONDS.sleep(50);
        }

        TimeUnit.SECONDS.sleep(1);

        for(int i=0;i<10;i++){
            synchronized (lock) {
                System.out.println("唤醒一个线程");
                lock.notify();
                //TODO 1
                TimeUnit.MILLISECONDS.sleep(10);
            }
            //TODO 2
//            System.out.println("释放一个锁");
//            TimeUnit.MILLISECONDS.sleep(10);
        }
        TimeUnit.SECONDS.sleep(1);

        System.out.println("wait顺序:"+waitList.toString());
        System.out.println("唤醒顺序:"+notifyList.toString());
    }


    /**
     * 当我们 分别注释 todo 1 和 2
     * 的时间sleep的时候  我们会发现不同的效果
     * 当 1 部分代码有效的时候  是无序随机的唤醒线程
     * 当 2 部分代码有效的时候  是有序的唤醒线程
     *
     * 这就要问个为什么了，为什么呢？
     * 为什么大多说人都认为notify是随机唤醒线程的呢？
     * 这个时候你是不是在想  毕竟notify()并没有制定需要唤醒的线程啊  这么说也没问题  接下来看原因
     *
     * 一问：notify是立即释放锁的吗？
     * 首先研究一下 WaitAndNotify 类方法，上一篇文章
     * 
     * https://blog.csdn.net/qq_34129814/article/details/117222339
     *
     * 答案是  不是的
     *
     * 二问：为啥 一行代码 位置的不同 引发的结果天壤之别
     *
     * 细心的话 你会注意到我们 在外层加了一个synchronized 锁
     *
     *
     * lock.notify();去唤醒等待线程, 我们假设唤醒了线程A;
     * 但是因为后面还要执行TimeUnit.MILLISECONDS.sleep(10)所以lock锁并没有被释放!
     * 当TimeUnit.MILLISECONDS.sleep(10)执行完毕后, lock被释放,
     *
     * 此时被唤醒的线程A想获取lock,
     * 但是我们的for循环中synchronized (lock)也想继续获取lock,
     * 于是两者发生了锁竞争.
     *
     * 由于synchronized实际上不是公平锁，其锁竞争的机制具有随机性
     * 这就导致了最终, 我们看到的结果好像是随机的!
     * 当我们把TimeUnit.MILLISECONDS.sleep(10);移出synchronized同步块后
     * lock锁立即被释放了,
     * 并且紧跟的 TimeUnit.SECONDS.sleep(1)确保被唤醒的线程能够获得lock锁立刻执行,
     * 所以, 我们看到的结果才是正确的!
     *
     * 具体原因 wait 内部采用了队列 具有公平性  是按照顺序插入的
     * 而notify是顺序执行的。所以就先进先出
     *
     * 结论：  有序的！！！！
     *
     */
}

一问：notify是立即释放锁的吗？
首先研究一下 WaitAndNotify 类方法，上一篇文章
https://blog.csdn.net/qq_34129814/article/details/117222339

二问：为啥 一行代码 位置的不同 引发的结果天壤之别 一个是有序 一个是无序？