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

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

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

要点： 

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

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、扩展

图中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);
        }
    }