Java多线程 Guarded Suspension设计模式

Java多线程中的Guarded Suspension设计模式利用了等待-通知机制来实现线程间的协作。该模式常用于多个线程之间共享资源的情况下，其中一个线程需要等待另一个线程的结果才能进行后续操作。下面是Guarded Suspension模式的详细攻略和两个示例说明。

Guarded Suspension设计模式

Guarded Suspension设计模式中有以下三个角色：

1. Guarded Object：受保护的对象，用于提供线程等待和通知机制。
2. Guarded Action：受保护的操作，用于实现Guarded Object中的方法，包含等待和唤醒等关键逻辑。
3. Guarded Suspension模式：用于将Guarded Object和Guarded Action连接起来的设计模式。

Guarded Object是一个类，其包含了等待和唤醒等方法，如wait()、notify()和notifyAll()等。Guarded Action用于实现Guarded Object中的方法，其中使用了synchronized关键字进行线程同步，以便在Guarded Object被唤醒时执行相应的操作。

示例一

下面我们将介绍一个简单的示例，实现了Guarded Suspension设计模式的基本原理。

public class GuardedObject {
    private Object response;

    public synchronized Object get() throws InterruptedException {
        while(response == null) {
            wait();
        }
        return response;
    }

    public synchronized void put(Object response) {
        this.response = response;
        notifyAll();
    }
}

public class GuardedAction {
    public void execute() throws InterruptedException {
        GuardedObject guardedObject = new GuardedObject();
        // 模拟后台任务
        new Thread(() -> {
            try {
                String result = "Hello World";
                guardedObject.put(result);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }).start();

        // 获取结果
        Object result = guardedObject.get();
        System.out.println("Result: " + result);
    }
}

public class Main {
    public static void main(String[] args) {
        try {
            GuardedAction action = new GuardedAction();
            action.execute();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果如下：

Result: Hello World

在这个示例中，GuardedObject对象提供了get()和put()两个方法，get()方法用于获取结果，而put()方法用于向GuardedObject对象中存储结果。GuardedAction对象调用execute()方法时，会在另一个线程中执行后台任务，并将结果存储在GuardedObject对象中。execute()方法会在当前线程等待，直到GuardedObject对象中有结果被存储，之后再返回结果。

示例二

接下来，我们将介绍一个更为实用的示例，用于解决一个订单支付的问题，其中包括订单信息的缓存和支付结果的通知。以下是示例的代码：

public class Order {
    private String orderId;
    private double amount;
    private boolean isFinished;

    // 构造方法和getter/setter方法省略
}

public class OrderCache {
    private Map<String, Order> cache = new ConcurrentHashMap<>();

    public void addOrder(Order order) {
        cache.put(order.getOrderId(), order);
    }

    public Order getOrder(String orderId) throws InterruptedException {
        Order order = cache.get(orderId);
        if(order == null) {
            GuardedObject guardedObject = new GuardedObject();
            synchronized (guardedObject) {
                cache.put(orderId, null);
                OrderServiceImpl.payOrder(orderId, new PaymentCallback() {
                    @Override
                    public void onComplete(boolean success) {
                        Order order = cache.get(orderId);
                        if(order == null) {
                            order = new Order(orderId, 0, false);
                            cache.put(orderId, order);
                        }
                        order.setFinished(success);
                        guardedObject.put(order);
                    }
                });
                return (Order) guardedObject.get();
            }
        }
        return order;
    }
}

public class OrderServiceImpl {
    public static void payOrder(String orderId, PaymentCallback callback) {
        new Thread(() -> {
            try {
                Thread.sleep(5000);
                callback.onComplete(true);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

public interface PaymentCallback {
    void onComplete(boolean success);
}

public class Main {
    public static void main(String[] args) {
        OrderCache orderCache = new OrderCache();
        try {
            Order order = orderCache.getOrder("20210716-001");
            System.out.println("Order Id: " + order.getOrderId() + ", Finished: " + order.isFinished());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在这个示例中，OrderCache对象用于缓存订单信息，并提供了getOrder()方法来获取订单信息。如果订单信息尚未缓存，系统会调用OrderServiceImpl对象的payOrder()方法进行支付，并使用GuardedObject对象来等待支付结果。当支付结果返回后，系统会存储结果到实际的Order对象中，并使用GuardedObject对象来通知等待的线程获取结果。

运行结果如下：

Order Id: 20210716-001, Finished: true

在上面的示例中，GuardedObject对象的put()方法会将支付结果存储到新创建的Order对象中，而get()方法会将这个Order对象返回。这样，就可以通过Guarded Suspension设计模式来实现订单支付的功能，提供了较好的可扩展性和可维护性。