1.线程间通知等待机制是什么？

​ 通知等待机制是指一个线程A 调用了对象O 的wait()方法进入等待状态，而另一个线程B调用了对象O 的notify()或者notifyAll()方法，线程A 收到通知后从对象O 的wait()方法返回，进而执行后续操作。上述两个线程通过对象O 来完成交互，而对象上的wait()和notify/notifyAll()的关系就如同开关信号一样，用来完成等待方和通知方之间的交互工作。
​ notify()：
​ 通知一个在对象上等待的线程,使其从wait 方法返回,而返回的前提是该线程获取到了对象的锁，没有获得锁的线程重新进入WAITING 状态。
​ notifyAll()：
​ 通知所有等待在该对象上的线程
​ wait():
​ 调用该方法的线程进入WAITING 状态,只有等待另外线程的通知或被中断才会返回.需要注意,调用wait()方法后,会释放对象的锁
​ wait(long)
​ 超时等待一段时间,这里的参数时间是毫秒,也就是等待长达n 毫秒,如果没有通知就超时返回
​ wait (long,int)
​ 对于超时时间更细粒度的控制,可以达到纳秒

2.线程协作机制如何使用？

等待方：

1
2
3
4
5
6
7
8
9
10
11
12
1）获取对象的锁。
2）如果条件不满足，那么调用对象的wait()方法，被通知后仍要检查条件。
3）条件满足则执行对应的逻辑。

private final Object lock = new Object();

synchronized (lock) {
	while (条件不满足) {
        lock.wait();  // 释放持有的锁
    }
    // 执行期待的程序
}

通知方:

1
2
3
4
5
6
7
8
9
1）获得对象的锁。
2）改变条件。
3）通知所有等待在对象上的线程。
    
synchronized (lock) {
	// 执行前置程序，修改条件
    lock.notifyAll(); 
    // notify()和notifAll()都不会对锁进行操作，所以一般会在synchronized最后一行才调用notify()或者notifyAll()方法
}

3.等待超时模式实现一个连接池(Handler从消息队列拿消息也是这个原理)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
public class DBPool {

    /*容器，存放连接*/
    private static LinkedList<Connection> pool = new LinkedList<Connection>();

    /*限制了池的大小=20*/
    public DBPool(int initialSize) {
        if (initialSize > 0) {
            for (int i = 0; i < initialSize; i++) {
                pool.addLast(SqlConnectImpl.fetchConnection());
            }
        }
    }

    /*释放连接,通知其他的等待连接的线程*/
    public void releaseConnection(Connection connection) {
        if (connection != null) {
            synchronized (pool){
                pool.addLast(connection);
                //通知其他等待连接的线程
                pool.notifyAll();
            }
        }
    }

    /*获取*/
    // 在mills内无法获取到连接，将会返回null 1S
    public Connection fetchConnection(long mills)
            throws InterruptedException {
        synchronized (pool){
            //永不超时
            if(mills<=0){
                while(pool.isEmpty()){
                    pool.wait();
                }
                return pool.removeFirst();
            }else{
                /*超时时刻*/
                long future = System.currentTimeMillis()+mills;
                /*等待时长*/
                long remaining = mills;
                while(pool.isEmpty()&&remaining>0){
                    pool.wait(remaining);
                    /*唤醒一次，重新计算等待时长*/
                    remaining = future-System.currentTimeMillis();
                }
                Connection connection = null;
                // 超时的情况下pool可能是空
                if(!pool.isEmpty()){
                    connection = pool.removeFirst();
                }
                return connection;
            }
        }

    }
}

4.调用yield() 、sleep()、wait()、notify()等方法对锁有何影响？

  • yield() 、sleep()被调用后，都不会释放当前线程所持有的锁。
  • 调用wait()方法后，会释放当前线程持有的锁，而且当前被唤醒后，会重新去竞争锁，锁竞争到后才会执行wait 方法后面的代码。
  • 调用notify()系列方法后，对锁无影响，线程只有在syn 同步代码执行完后才会自然而然的释放锁，所以notify()系列方法一般都是synchronized 同步代码的最后一行。

测试用例代码见： git@github.com:oujie123/UnderstandingOfThread.git