对多线程中的wait（）,notify()/notifyAll()的理解

1.线程间的协作？

线程之间相互配合完成工作。存在着一个生产者和一个消费者的角色。例如我们早上去排队买早餐，老板做好之后就会叫我们的场景；该场景中老板相当于是生产者，我们是一个消费者的角色，在收到老板的通知之后去领取自己的早餐。
存在的问题：
1.可能存在不及时的问题，因为消费者去消费的前提是必须生产者已经生成了消息，所以会出现消费者需要等待的情况。
2.消耗更多的资源，维护这个生产-消费的协作模式是需要花费更多的资源的。

2.三个方法的作用是什么？

1.notify()：
通知一个在对象上等待的线程,使其从wait 方法返回,而返回的前提是该线程
获取到了对象的锁，没有获得锁的线程重新进入 WAITING 状态。但是唤醒的线程是随机的。
2.notifyAll()：
通知所有等待在该对象上的线程
3.wait()
调用该方法的线程进入 WAITING 状态,只有等待另外线程的通知或被中断
才会返回.需要注意,调用 wait()方法后,会释放对象的锁
4.wait(long)
超时等待一段时间,这里的参数时间是毫秒,也就是等待长达n 毫秒,如果没有 通知就超时返回
5.wait (long,int)
对于超时时间更细粒度的控制,可以达到纳秒

3.使用注意事项？

1.消费者需要遵循的规则：
1）获取对象的锁。
2）如果条件不满足，那么调用对象的 wait()方法，被通知后仍要检查条件。
3）需要满足如下的代码规范

synchronized (对象){
            while(条件不满足) {
                对象.wait();
            }
            对应的处理逻辑
        }

2.生产者需要遵循的规则：
1）获得对象的锁。
2）改变条件。
3）通知所有等待在对象上的线程。

synchronized (对象){
            改变条件
            对象.notifyAll();
        }

3、wait()、notify/notifyAll() 方法是Object的本地final方法，无法被重写。
4、wait()使当前线程阻塞，前提是 必须先获得锁，一般配合synchronized 关键字使用，即，一般在synchronized 同步代码块里使用 wait()、notify/notifyAll() 方法。
5、 由于 wait()、notify/notifyAll() 在synchronized 代码块执行，说明当前线程一定是获取了锁的。
当线程执行wait()方法时候，会释放当前的锁，然后让出CPU，进入等待状态。
只有当 notify/notifyAll() 被执行时候，才会唤醒一个或多个正处于等待状态的线程，然后继续往下执行，直到执行完synchronized 代码块的代码或是中途遇到wait() ，再次释放锁。
也就是说，notify/notifyAll() 的执行只是唤醒沉睡的线程，而不会立即释放锁，锁的释放要看代码块的具体执行情况。所以在编程中，尽量在使用了notify/notifyAll() 后立即退出临界区，以唤醒其他线程让其获得锁
6、wait() 需要被try catch包围，以便发生异常中断也可以使wait等待的线程唤醒。
7、notify 和wait 的顺序不能错，如果A线程先执行notify方法，B线程在执行wait方法，那么B线程是无法被唤醒的。
8、notify 和 notifyAll的区别
notify方法只唤醒一个等待（对象的）线程并使该线程开始执行。所以如果有多个线程等待一个对象，这个方法只会唤醒其中一个线程，选择哪个线程取决于操作系统对多线程管理的实现。notifyAll 会唤醒所有等待(对象的)线程，尽管哪一个线程将会第一个处理取决于操作系统的实现。如果当前情况下有多个线程需要被唤醒，推荐使用notifyAll 方法。比如在生产者-消费者里面的使用，每次都需要唤醒所有的消费者或是生产者，以判断程序是否可以继续往下执行。
9、在多线程中要测试某个条件的变化，使用if 还是while？
　　要注意，notify唤醒沉睡的线程后，线程会接着上次的执行继续往下执行。所以在进行条件判断时候，可以先把 wait 语句忽略不计来进行考虑；显然，要确保程序一定要执行，并且要保证程序直到满足一定的条件再执行，要使用while进行等待，直到满足条件才继续往下执行。

4.等待超时模式实现一个数据库连接池？

调用场景：调用一个方法时等待一段时间（一般来说是给定一个时间段），
如果该方法能够在给定的时间段之内得到结果，那么将结果立刻返回，反之，超 时返回默认结果。
类似于数据库的连接池的工作原理，获取连接和释放连接。

private static LinkedList<Connection> pool = new LinkedList<Connection>();

    public DBPool(int initialSize) {
        if (initialSize > 0) {
            for (int i = 0; i < initialSize; i++) {
                pool.addLast(SqlConnectImpl.fetchConnection());
            }
        }
    }

    /**
     * 释放连接（在连接用完之后归还到连接池）
     * @param connection
     */
    public void releaseConnection(Connection connection) {
        if (connection != null) {
            //TODO
            synchronized (pool) {
                pool.addLast(connection);
                //此时连接池中已归还一个连接，唤醒其他线程去获取该连接
                pool.notifyAll();
            }
        }
    }

    /**
     * 获取连接
     * @param mills
     * @return
     * @throws InterruptedException
     */
    // 在mills内无法获取到连接，将会返回null
    public Connection fetchConnection(long mills) throws InterruptedException {

        //判断是否需要超时处理
        synchronized (pool) {
            //表示不需要进行获取连接的等待超时处理
            if(mills <= 0){
                //如果连接池为空，则进入等待，否则直接从链表中取出首元素
                while(pool.isEmpty()) {
                    pool.wait();
                }
                return pool.removeFirst();
            }
            else{
                //计算出当前时间的超时时刻
                long overTimes = System.currentTimeMillis()+mills;
                long needWait = mills;
                //判断如果超时情况下，连接池为空，
                //并且线程还是处于等待超时时间之内的情况下可以继续等待
                while(pool.isEmpty() && needWait > 0) {
                    pool.wait(needWait);
                    //在每次被唤醒的情况下，因为还存在没有获取到连接的线程，
                    //所以需要计算其他没有获取到连接的线程的剩余等待超时时间
                    needWait = overTimes - System.currentTimeMillis();
                }
                //在线程超过了超时时间之后则返回一个null
                Connection connection = null;
                //在某个线程从连接池中获取到连接后则正常返回
                if(!pool.isEmpty()) {
                    connection = pool.removeFirst();
                }
                return connection;
            }

        }

    }