/* * Copyright (c) 2008, 2009, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation.  Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package sun.nio.ch; import java.nio.channels.*;import java.util.concurrent.*;import java.io.IOException; /** * A Future for a pending I/O operation. A PendingFuture allows for the * attachment of an additional arbitrary context object and a timer task. */ final class PendingFuture<V,A> implements Future<V> {    private static final CancellationException CANCELLED =        new CancellationException();     private final AsynchronousChannel channel;    private final CompletionHandler<V,? super A> handler;    private final A attachment;     // true if result (or exception) is available    private volatile boolean haveResult;    private volatile V result;    private volatile Throwable exc;     // latch for waiting (created lazily if needed)    private CountDownLatch latch;     // optional timer task that is cancelled when result becomes available    private Future<?> timeoutTask;     // optional context object    private volatile Object context;     PendingFuture(AsynchronousChannel channel,                  CompletionHandler<V,? super A> handler,                  A attachment,                  Object context)    {        this.channel = channel;        this.handler = handler;        this.attachment = attachment;        this.context = context;    }     PendingFuture(AsynchronousChannel channel,                  CompletionHandler<V,? super A> handler,                  A attachment)    {        this.channel = channel;        this.handler = handler;        this.attachment = attachment;    }     PendingFuture(AsynchronousChannel channel) {        this(channel, null, null);    }     PendingFuture(AsynchronousChannel channel, Object context) {        this(channel, null, null, context);    }     AsynchronousChannel channel() {        return channel;    }     CompletionHandler<V,? super A> handler() {        return handler;    }     A attachment() {        return attachment;    }     void setContext(Object context) {        this.context = context;    }     Object getContext() {        return context;    }     void setTimeoutTask(Future<?> task) {        synchronized (this) {            if (haveResult) {                task.cancel(false);            } else {                this.timeoutTask = task;            }        }    }     // creates latch if required; return true if caller needs to wait    private boolean prepareForWait() {        synchronized (this) {            if (haveResult) {                return false;            } else {                if (latch == null)                    latch = new CountDownLatch(1);                return true;            }        }    }     /**     * Sets the result, or a no-op if the result or exception is already set.     */    void setResult(V res) {        synchronized (this) {            if (haveResult)                return;            result = res;            haveResult = true;            if (timeoutTask != null)                timeoutTask.cancel(false);            if (latch != null)                latch.countDown();        }    }     /**     * Sets the result, or a no-op if the result or exception is already set.     */    void setFailure(Throwable x) {        if (!(x instanceof IOException) && !(x instanceof SecurityException))            x = new IOException(x);        synchronized (this) {            if (haveResult)                return;            exc = x;            haveResult = true;            if (timeoutTask != null)                timeoutTask.cancel(false);            if (latch != null)                latch.countDown();        }    }     /**     * Sets the result     */    void setResult(V res, Throwable x) {        if (x == null) {            setResult(res);        } else {            setFailure(x);        }    }     @Override    public V get() throws ExecutionException, InterruptedException {        if (!haveResult) {            boolean needToWait = prepareForWait();            if (needToWait)                latch.await();        }        if (exc != null) {            if (exc == CANCELLED)                throw new CancellationException();            throw new ExecutionException(exc);        }        return result;    }     @Override    public V get(long timeout, TimeUnit unit)        throws ExecutionException, InterruptedException, TimeoutException    {        if (!haveResult) {            boolean needToWait = prepareForWait();            if (needToWait)                if (!latch.await(timeout, unit)) throw new TimeoutException();        }        if (exc != null) {            if (exc == CANCELLED)                throw new CancellationException();            throw new ExecutionException(exc);        }        return result;    }     Throwable exception() {        return (exc != CANCELLED) ? exc : null;    }     V value() {        return result;    }     @Override    public boolean isCancelled() {        return (exc == CANCELLED);    }     @Override    public boolean isDone() {        return haveResult;    }     @Override    public boolean cancel(boolean mayInterruptIfRunning) {        synchronized (this) {            if (haveResult)                return false;    // already completed             // notify channel            if (channel() instanceof Cancellable)                ((Cancellable)channel()).onCancel(this);             // set result and cancel timer            exc = CANCELLED;            haveResult = true;            if (timeoutTask != null)                timeoutTask.cancel(false);        }         // close channel if forceful cancel        if (mayInterruptIfRunning) {            try {                channel().close();            } catch (IOException ignore) { }        }         // release waiters        if (latch != null)            latch.countDown();        return true;    }}