defaultfuture.java

银行项目为后台ｓｏｃｋｅｔ通信写的程序

/****************************************************************************
 * Package		: com.ecSolutions.ecAppServer.server.session
 * File			: DefaultFuture.java
 * Create Date  : 2007-7-20
 * Author		: Steven Chen
 * 
 * Copyright(C) 2006 ecSolutions(shanghai) Co.,Limited.All Rights Reserved.
 *			
 ***************************************************************************/
package com.ecSolutions.ecAppServer.server.session;

import com.ecSolutions.ecAppServer.server.Future;
import com.ecSolutions.ecAppServer.server.FutureListener;
import com.ecSolutions.ecAppServer.server.Session;
import com.ecSolutions.ecAppServer.server.session.dispatcher.Dispatcher;
import com.ecSolutions.ecAppServer.server.session.dispatcher.DispatcherFactory;
import com.ecSolutions.ecAppServer.server.util.ElapsedTime;
import edu.emory.mathcs.backport.java.util.LinkedList;
import edu.emory.mathcs.backport.java.util.Queue;

/**
 * Default future implementation.
 * 
 * @author Steven Chen
 * @version $Id: DefaultFuture.java,v 1.2 2007/07/26 03:33:50 stevenchen Exp $
 */
public class DefaultFuture implements Future {

    private final Session session;
    private final Dispatcher dispatcher = DispatcherFactory.getDispatcher();

    private volatile Queue listeners; // lazy load

    private volatile boolean completed = false;
    private volatile boolean succeeded = false;

    public DefaultFuture(Session session) {
        this.session = session;
    }

    public DefaultFuture(Session session, boolean succeeded) {
        this.session = session;
        completed = true;
        this.succeeded = succeeded;
    }

    public Session getSession() {
        return session;
    }

    protected void caughtException(Throwable throwable) {
        session.getSessionFilterChain(false).exceptionCaught(throwable);
    }

    private void dispatchFutureCompleted(final FutureListener listener) {
        dispatcher.dispatch(session, new Runnable() {

            private void futureCompleted(FutureListener listener) {
                try {
                    listener.futureCompleted(DefaultFuture.this);
                } catch (Throwable e) {
                    caughtException(e);
                }
            }

            public void run() {
                if (listener != null)
                    futureCompleted(listener);
                else if (listeners != null) {
                    for (FutureListener listener = null; (listener = (FutureListener) listeners
                            .poll()) != null;) {
                        futureCompleted(listener);
                    }
                }
            }
        });
    }

    public void addListener(FutureListener listener) {
        if (listener != null) {
            // double-checked locking, it can work for 32-bit primitive values
            if (completed) {
                dispatchFutureCompleted(listener);
            } else {
                synchronized (this) {
                    if (completed)
                        dispatchFutureCompleted(listener);
                    else {
                        if (listeners == null) // lazy load
                            listeners = new LinkedList();
                        listeners.add(listener);
                    }
                }
            }
        }
    }

    public void removeListener(FutureListener listener) {
        if (!completed) { // double-checked locking
            synchronized (this) {
                if (!completed && listeners != null)
                    listeners.remove(listener);
            }
        }
    }

    public boolean complete() {
        if (!completed) {
            synchronized (this) {
                while (!completed) {
                    dispatcher.block(); // block dispatcher
                    try {
                        wait();
                    } catch (InterruptedException e) {
                    }
                }
            }
        }
        return succeeded;
    }

    public boolean complete(int timeout) {
        if (timeout < 0)
            throw new IllegalArgumentException();
        if (!completed) {
            ElapsedTime startTime = new ElapsedTime();
            synchronized (this) {
                while (!completed) {
                    long waitTime = timeout - startTime.getElapsedTime();
                    if (waitTime <= 0)
                        break;
                    dispatcher.block(); // block dispatcher
                    try {
                        wait(waitTime);
                    } catch (InterruptedException e) {
                    }
                }
            }
        }
        return completed;
    }

    public boolean isCompleted() {
        return completed;
    }

    public boolean isSucceeded() {
        return succeeded;
    }

    public synchronized void setSucceeded(boolean succeeded) {
        if (completed)
            throw new IllegalStateException(
                    "can't change the state of a completed future");
        completed = true;
        this.succeeded = succeeded;

        notifyAll();

        dispatchFutureCompleted(null);
    }
}