這些都是根據我最近看的《Java實戰指南多執行緒程式設計（設計模式篇）》所得整理。

模式名稱

Guarded Suspension（保護性暫掛模式）

模式面對的問題

多執行緒程式設計中，往往將一個任務分解為不同的部分，將其交由不同的執行緒來執行，這些執行緒相互協作的時候，會出現一個執行緒等待另一個執行緒一定操作過後才能進行的情景，這個時候就需要這個執行緒退出執行。

解決方法

有一個類GuardedObject包含受保護方法的物件，存放被保護物件的方法和被保護物件的喚醒方法。一個類GuardedAction抽象目標動作，並關聯了目標動作鎖需的保護條件.一個ConcreteGuardedAction應用程式鎖體現的具體目標動作及其關聯的保護條件，一個Predicate抽象保護條件，ConCretePredicate應用程式鎖實現的具體保護條件，Blocker負責執行受保護的方法所線上程的掛起和喚醒。並執行ConcreteGuardedAction鎖執行的目標操作。ConditionVarBlocker給予Java條件變數實現的Blocker.

例子程式碼

這也是書上的程式碼，需求是：某系統有個告警功能模組，改模組的主要功能是將其接收到的告警資訊傳送給告警伺服器。
AlarmAgent類

public class ALarmAgent {
    //用於記錄AlarmAgent
    private volatile boolean connectedToServer = false;
    //模式角色：GuardedSuspension.Predicate
    private final Predicate agentConnected = new Predicate(){
        @Override
        public
 
 boolean evaluate(){
            return connectedToServer;
        }
    };
    //模式角色GuaededSuspension.Blocker
    private final Blocker blocker = new ConditionVarBlocker();
    //心跳定時器
    private final Timer heartbeatTimer = new Timer(true); 

    //傳送告警資訊
    public void sendAlarm(final AlarmInfo alarm) throws
 
 Exception {
        GuardedAction<Void> guardedAction = new GuardedAction<Void>(agentConnected){
            public Void call()throws Exception{
                doSendAlarm(alarm);
                return null;
            }
        };
        blocker.callWithGuard(guardedAction);
    }

    //通過網路連結講告警資訊傳送給告警伺服器
    private void doSendAlarm(AlarmInfo alarm){
        //省略其他與設計模式無關的程式碼
        Debug.info("sending alarm"+alarm);
        //模擬傳送告警值伺服器的耗時
        try{
            Thread.sleep(50);
        }catch(Exception e){

        }
    }

    public void init(){
        //省略其他與設計模式無關的程式碼
        //告警伺服器連線執行緒
        Thread connectingThread = new Thread(new ConnectingTask());

        connectingThread.start();

        heartbeatTimer.schedule(new HeartbeatTask(), 60000,2000);
    }

    public void disconnect(){
        //省略其他與設計模式無關的程式碼
        Debug.info("disconnected from alarm server.");
        connectedToServer = false;
    }

    protected void onConnected(){
        try{
            blocker.singalAfter(new Callable<Boolean>(){
                @Override
                public Boolean call(){
                    connectedToServer = true;
                    Debug.info("connnected to server");
                    return Boolean.TRUE;
                }
            });
        }catch(Exception e){
            e.printStackTrace();
        }
    }


    protected void onDisconnected(){
        connectedToServer = false;
    }

    //負責與告警伺服器建立網路連結
    private class ConnectingTask implements Runnable{
        @Override
        public void run(){
            //省略其他與設計模式無關的程式碼
            //模擬連線操作耗時
            try{
                Thread.sleep(100);
            }catch(InterruptedException e){
                ;
            }
        }
    }

    //心跳定時任務：定時檢車與該井伺服器的連結是否正常，發現連結異常後自動重新連結
    private class HeartbeatTask extends TimerTask{
        @Override
        public void run(){
            //省略其他與設計模式無關的程式碼
            if(!testConnection()){
                onDisconnected();
                reconnect();
            }
        }
        private boolean testConnection(){
            //省略其他與設計模式無關的程式碼
            return true;
        }

        private void reconnect(){
            ConnectingTask connectingThread = new ConnectingTask();
            //直接在心跳定時器執行緒中執行
            connectingThread.run();
        }
    }
}

暫掛的sendAlarm

public interface Predicate {
    boolean evaluate();
}

public abstract class GuardedAction<V> implements Callable<V>{
    protected final Predicate guard;
    public GuardedAction(Predicate guard){
        this.guard = guard;
    }
}

public interface Blocker {
    //在保護條件城裡時執行目標動作；否則阻塞當前執行緒，知道保護條件成立
    <V> V callWithGuard(GuardedAction<V>guardedAction) throws Exception;
    //執行 stateOperation所制定的操作後，決定是否喚醒本Blocker
    void signalAfter(Callable<Boolean>stateOperation) throws Exception;
    void signal() throws InterruptedException;
    //執行stateOperation所制定的操作後，決定是否喚醒本Blocker
    void broadcastAfter(Callable<Boolean> stateOperation) throws Exception;
}

public class ConditionVarBlocker implements Blocker{
    private final Lock lock;

    private final Condition condition;

    public ConditionVarBlocker(Lock lock){
        this.lock = lock;
        this.condition = lock.newCondition();
    }

    public ConditionVarBlocker(){
        this.lock = new ReentrantLock();
        this.condition = lock.newCondition();
    }

    public <V> V callWithGuard(GuardedAction<V> guardedAction) throws Exception {
        lock.lockInterruptibly();
        V result;
        try{
            final Predicate guard = guardedAction.guard;
            while(!guard.evaluate()){
                condition.await();
            }
            result = guardedAction.call();
            return result;
        }finally{
            lock.unlock();
        }
    }

    public void broadcastAfter(Callable<Boolean> stateOperation)
            throws Exception {
        lock.lockInterruptibly();
        try{
            if(stateOperation.call()){
                condition.signal();
            }
        }finally{
            lock.unlock();
        }
    }



    public void signal() throws InterruptedException {
        lock.lockInterruptibly();
        try{
            condition.signal();
            }finally{
                lock.unlock();
        }
    }

    public void signalAfter(Callable<Boolean> stateOperation) throws Exception {
        lock.lockInterruptibly();
        try{
            if(stateOperation.call()){
                condition.signalAll();
            }
        }finally{
            lock.unlock();
        }

    }
}

需要關注的問題

1. 記憶體可見性和鎖洩露
2. 執行緒被過早喚醒
3. 巢狀監視器鎖死
4. 可能增加JVM垃圾回收的負擔