同步模式之保护性暂停

• 同步模式之保护性暂停
  就是一个线程等待另外一个线程的结果。

public class GuardedObject{
    private Object object;
    private boolean ready = false;

    synchronized public Object get(){
        while(!ready){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        return object;
    }

    synchronized public Object get(long timeout){
        long left;
        long startTs = System.currentTimeMillis();
        while(!ready){
            left = startTs + timeout - System.currentTimeMillis();
            if(left<=0){
                return null;
            }

            try {
                // wait不一定会等待left这么长的时间，因为可能会被打断
                wait(left);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        return object;
    }

    synchronized public void complete(Object object) {
        this.object = object;
        notifyAll();
    }

    public static void test(){
        GuardedObject GO = new GuardedObject();
        Thread t1 = new Thread(
                ()->{
                    System.out.println("等待结果...");
                    GO.get(500);
                    System.out.println("得到结果...");
                }
        );
        t1.start();

        Thread t2 = new Thread(
                ()->{
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("发送结果...");
                    GO.complete(new Object());
                }
        );
        t2.start();
        try {
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}