【面试：并发篇17：多线程：设计模式】保护性暂停

【面试：并发篇17：多线程：设计模式】保护性暂停

00.前言

如果有任何问题请指出，感谢。

01.介绍

线程通信时的手段，用在一个线程等待另一个线程的执行结果
注意点

1.有一个结果需要从一个线程传递到另一个线程，让他们关联到同一个GuardedObject
2.如果有结果不断从一个线程到另一个线程那么可以使用消息队列，后续也会用此设计模式实现
3.join、Future的实现，采用的也是此设计模式，后续也会分析
4.因为要等待另一方的结果，因此归类到同步模式

图片解释

t1需要从GuardedObject中获取response值，t2需要从GuardedObject中给response赋值

02.实现

设计模式代码

@Slf4j(topic = "c.TestBH")
public class TestBH {
    // 线程1 等待 线程2 的下载结束
    public static void main(String[] args) {
        GuardedObjet guardedObjet = new GuardedObjet();
        new Thread(()->{
            // 等待结果
            log.debug("等待结果");
            try {
                List<String> list = (List<String>) guardedObjet.get();
                log.debug("结果大小：{}",list.size());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"t1").start();

        new Thread(()->{
            log.debug("执行下载");
            try {
                List<String> list = Downloader.download();
                guardedObjet.complete(list);
            } catch (IOException e) {
                e.printStackTrace();
            }
        },"t2").start();
    }
}

class GuardedObjet{
    // 结果
    private Object response;

    // 获取结果
    public Object get() throws InterruptedException {
        synchronized (this){
            // 没有结果
            while (response==null){
                this.wait();
            }
            return response;
        }
    }

    // 产生结果
    public void complete(Object response){
        synchronized (this){
            // 给response赋值
            this.response=response;
            this.notifyAll();
        }
    }
}

Downloader代码

public class Downloader {
    public static List<String> download() throws IOException {
        HttpURLConnection conn = (HttpURLConnection) new URL("https://www.baidu.com/").openConnection();
        List<String> lines = new ArrayList<>();
        try (BufferedReader reader =
                     new BufferedReader(new InputStreamReader(conn.getInputStream(), StandardCharsets.UTF_8))) {
            String line;
            while ((line = reader.readLine()) != null) {
                lines.add(line);
            }
        }
        return lines;
    }
}

结果

22:59:11.757 c.TestBH [t2] - 执行下载
22:59:11.757 c.TestBH [t1] - 等待结果
22:59:14.999 c.TestBH [t1] - 结果大小：3

解释
我们这个例子是t1线程获取response的数据，t2线程给response赋值为 Downloader.download();

03.优点

有朋友可能会说我直接把response设置为main的成员方法，然后t1 t2线程共享 用join来传递消息不行吗？可以但是不建议，因为用join是有缺点的：使用join会导致 t1线程必须等待t2线程结束可可以运行，但是t1线程实际中又不止这一个功能需要运行。

04.扩展-增加超时

扩展超时的意思时，我们不能一直等，万一发送的过于慢了 我们就直接把线程唤醒

@Slf4j(topic = "c.TestBH")
public class TestBH {
    // 线程1 等待 线程2 的下载结束
    public static void main(String[] args) {
        GuardedObjet guardedObjet = new GuardedObjet();
        new Thread(()->{
            // 等待结果
            log.debug("等待结果");
            try {
                String s = (String) guardedObjet.get(2000);
                log.debug("结果是：{}",s);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"t1").start();

        new Thread(()->{
            log.debug("执行下载");
            Sleeper.sleep(1);
            guardedObjet.complete("asd");
        },"t2").start();
    }
}

class GuardedObjet{
    // 结果
    private Object response;

    // 获取结果
    public Object get() throws InterruptedException {
        synchronized (this){
            // 没有结果
            while (response==null){
                this.wait();
            }
            return response;
        }
    }

    public Object get(long timeout) throws InterruptedException {
        synchronized (this){
            // 开始时间
            long begin = System.currentTimeMillis();
            // 经历的时间
            long passedTime = 0;
            while (response==null){
                // 这一轮等待的时间
                long waitTime = timeout - passedTime;
                // 经历的时间超过了最大等待时间 退出循环
                if (waitTime<=0){
                    break;
                }
                this.wait(waitTime);

                // 求得经历时间
                passedTime = System.currentTimeMillis() - begin;
            }
            return response;
        }
    }

    // 产生结果
    public void complete(Object response){
        synchronized (this){
            // 给response赋值
            this.response=response;
            this.notifyAll();
        }
    }
}

结果

23:07:50.688 c.TestBH [t2] - 执行下载
23:07:50.688 c.TestBH [t1] - 等待结果
23:07:51.702 c.TestBH [t1] - 结果是：asd

解释
这个例子需要注意的点比较多，我们给get方法指定时间为2s，如果这个时间内没有获取到数据那么久唤醒t1线程 不过获取的数据为null，如果获取到了数据也唤醒t1线程 获取的数据为"asd"
需要注意的问题
1.为什么我们需要break，直接把wait设置为timeout不行吗？

很明显不行，因为我们没有break 只把wait设置为timeout 其实wait() 效果一样，因为就是给wait设置timeout 到了时间被唤醒，但是因为是while循环 导致再一次wait

2.我们加上break后，为什么不直接把wait指定时间设为timeout

因为timeout是最多应该等待的时间 假如为2s，我们如果直接把wait的指定时间设置为timeout的话，会导致，万一出现虚假唤醒的情况，例如我们在1s时虚假唤醒了t1线程 然后由于while循环 导致wait被再次执行，使得此时又wait了2s，最终t1线程真正被唤醒用了3s 超过是最大等待时间

3.为什么不wait了timeout时间后直接break

                this.wait(timeout)
                break;

因为这样做万一被虚假唤醒 就会直接break退出