并发编程学习（五）：设计模式~同步模式之保护性暂停

约定不等于承诺〃 2023-09-25 14:16 19阅读 0赞

## 1、保护性暂停 模式的定义 ##

保护性暂停 即Guarded Suspension，**用于在一个线程等待另一个线程的执行结果。**

要点：

*  有一个结果需要从一个线程传递到另一个线程，让它们关联同一个对象GuardedObject。
 *  如果有结果不断从一个线程到另一个线程，那么可以使用消息队列。
 *  JDK中，**join的实现、Future的实现，采用的就是此模式**。
 *  因为要等待另一方的结果，因此归类到 同步模式。

![5ce1eab692c44dcaa81b6d98c8564605.png][]

## 2、代码示例 ##

**详细的GuardedObject代码示例：**

public class GuardedObject {
    
        // 结果
        private Object response;
    
        /**
         * 获取结果
         *
         * @param timeout ：表示要等待的超时时间, 单位：毫秒
         * @return Object
         */
        public Object getResponse(long timeout) {
            synchronized (this) {
                // 开始时间
                long beginTime = System.currentTimeMillis();
                // 已经等待的时间
                long passedTime = 0;
    
                while (response == null) {
                    // 这一轮循环应该等待的时间
                    long waitTime = timeout - passedTime;
    
                    // 经历的时间超过了超时时间，则退出循环，不再等待
                    if (waitTime <= 0) {
                        break;
                    }
    
                    // 等待结果
                    try {
                        // 此处的wait时间为剩余的最大等待时间，如果中间被虚假唤醒，再次进入循环时，wait的等待时间会越来越小
                        this.wait(waitTime);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
    
                    // 经历的等待时间
                    passedTime = System.currentTimeMillis() - beginTime;
                }
                return response;
            }
        }
    
        /**
         * 生成结果
         * @param response
         */
        public void generateResponse(Object response) {
            synchronized (this) {
                // 给结果成员变量赋值
                this.response = response;
                this.notifyAll();
            }
        }
    }

**测试代码示例：**

@Slf4j
    public class TestGuardedObject {
    
        // 线程1 等待 线程2 的结果
        public static void main(String[] args) {
            GuardedObject guardedObject = new GuardedObject();
    
            new Thread(() -> {
                log.debug("begin...");
                // 2000表示最多等待2秒，2秒后不论是否拿到结果，都会返回response
                Object response = guardedObject.getResponse(2000);
                log.debug("结果是：{}",response);
            },"t1").start();
    
            new Thread(() -> {
                log.debug("begin...");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
    
                // 生成结果
                guardedObject.generateResponse(new Object());
            },"t2").start();
        }
    }

执行结果：

> 15:55:42.298 \[t2\] DEBUG com.example.common.thread.TestGuardedObject - begin...  
> 15:55:42.298 \[t1\] DEBUG com.example.common.thread.TestGuardedObject - begin...  
> 15:55:43.311 \[t1\] DEBUG com.example.common.thread.TestGuardedObject - 结果是：java.lang.Object@958b770

## 3、扩展 ##

![34c15f39cc8d426cafa0437d5714788d.png][]图中Futures就好比居民楼一层的信箱（每个信箱有房间编号），左侧t0、t2、t4就好比等待邮件的居民，右侧t1、t3、t5就好比邮递员。

如果需要在多个类之间使用GuardedObject对象，作为参数传递不是很方便，一次设计一个用来解耦的中间类，这样不仅能够解耦【结果等待者】和【结果生产者】，还能够同时支持多个任务的管理。

**解耦的中间类代码示例：**

/**
     * 解耦 t1、t2的中间类：通用的类
     *
     * 保护性暂停 模式：一个等待者 对应一个结果产生着。
     */
    public class Mailboxes {
    
        private static Map<Integer,GuardedObject> boxes = new Hashtable<>();
    
        private static int id = 1;
    
        // 产生唯一id
        private static synchronized int generateId() {
            return id++;
        }
    
        public static GuardedObject getGuardedObject(int id) {
            return boxes.remove(id);
        }
    
        public static GuardedObject createGuardedObject() {
            GuardedObject go = new GuardedObject(generateId());
            boxes.put(go.getId(), go);
            return go;
        }
    
        public static Set<Integer> getIds() {
            return boxes.keySet();
        }
    }

**GuardedObject改造后的代码示例：**

// 保护性暂停 模式：一个等待者 对应一个结果产生着。
    public class GuardedObject {
    
        // 标识GuardedObject
        private int id;
    
        public GuardedObject(int id) {
            this.id = id;
        }
    
        public int getId() {
            return id;
        }
    
        // 结果
        private Object response;
    
        /**
         * 获取结果
         *
         * @param timeout ：表示要等待的超时时间, 单位：毫秒
         * @return Object
         */
        public Object getResponse(long timeout) {
            synchronized (this) {
                // 开始时间
                long beginTime = System.currentTimeMillis();
                // 已经等待的时间
                long passedTime = 0;
    
                while (response == null) {
                    // 这一轮循环应该等待的时间
                    long waitTime = timeout - passedTime;
    
                    // 经历的时间超过了超时时间，则退出循环，不再等待
                    if (waitTime <= 0) {
                        break;
                    }
    
                    // 等待结果
                    try {
                        // 此处的wait时间为剩余的最大等待时间，如果中间被虚假唤醒，再次进入循环时，wait的等待时间会越来越小
                        this.wait(waitTime);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
    
                    // 经历的等待时间
                    passedTime = System.currentTimeMillis() - beginTime;
                }
                return response;
            }
        }
    
        /**
         * 生成结果
         * @param response
         */
        public void generateResponse(Object response) {
            synchronized (this) {
                // 给结果成员变量赋值
                this.response = response;
                this.notifyAll();
            }
        }
    }

测试代码示例：

public static void main(String[] args) {
            for (int i = 0; i < 3; i++) {
    
                new People().start();
    
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
    
                // 遍历所有的信件id
                for (Integer id: Mailboxes.getIds()) {
                    new Postman(id,"内容" + id).start();
                }
    
            }
        }
    
        /**
         * 居民类：收信
         */
        static class People extends Thread {
    
            @Override
            public void run() {
                GuardedObject guardedObject = Mailboxes.createGuardedObject();
                log.debug("开始收信, id:{}", guardedObject.getId());
                Object mail = guardedObject.getResponse(5000);
                log.debug("收到信, id:{},内容：{}", guardedObject.getId(), mail);
            }
        }
    
        /**
         * 邮递员类： 送信
         */
        static class Postman extends Thread {
    
            private int id;
            private String mail;
    
            public Postman(int id, String mail) {
                this.id = id;
                this.mail = mail;
            }
    
            @Override
            public void run() {
                GuardedObject guardedObject = Mailboxes.getGuardedObject(id);
                log.debug("送信, id:{},内容：{}", id, mail);
                guardedObject.generateResponse(mail);
            }
        }

[5ce1eab692c44dcaa81b6d98c8564605.png]: https://img-blog.csdnimg.cn/5ce1eab692c44dcaa81b6d98c8564605.png
[34c15f39cc8d426cafa0437d5714788d.png]: https://img-blog.csdnimg.cn/34c15f39cc8d426cafa0437d5714788d.png