FutureTask.h

Go to the documentation of this file.

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef _DECAF_UTIL_CONCURRENT_FUTURETASK_H_
#define _DECAF_UTIL_CONCURRENT_FUTURETASK_H_
 
#include <decaf/util/Config.h>
 
#include <decaf/lang/Thread.h>
#include <decaf/lang/Pointer.h>
#include <decaf/lang/exceptions/NullPointerException.h>
 
#include <decaf/util/concurrent/RunnableFuture.h>
#include <decaf/util/concurrent/Callable.h>
#include <decaf/util/concurrent/CancellationException.h>
#include <decaf/util/concurrent/ExecutionException.h>
#include <decaf/util/concurrent/TimeoutException.h>
#include <decaf/util/concurrent/TimeUnit.h>
#include <decaf/util/concurrent/locks/AbstractQueuedSynchronizer.h>
 
namespace decaf {
namespace util {
namespace concurrent {
 
    using decaf::lang::Pointer;
 
    template<typename T>
    class FutureTask : public RunnableFuture<T> {
    private:
 
        class FutureTaskAdapter : public decaf::util::concurrent::Callable<T> {
        private:
 
            decaf::lang::Runnable* task;
            decaf::util::concurrent::Callable<T>* callable;
            bool owns;
            T result;
 
        private:
 
            FutureTaskAdapter(const FutureTaskAdapter&);
            FutureTaskAdapter operator= (const FutureTaskAdapter&);
 
        public:
 
            FutureTaskAdapter(decaf::lang::Runnable* task, const T& result, bool owns = true) :
                decaf::util::concurrent::Callable<T>(), task(task), callable(NULL), owns(owns), result(result) {
            }
 
            FutureTaskAdapter(decaf::util::concurrent::Callable<T>* task, bool owns = true) :
                decaf::util::concurrent::Callable<T>(), task(NULL), callable(task), owns(owns), result(T()) {
            }
 
            virtual ~FutureTaskAdapter() {
                try{
                    if (owns) {
                        delete this->task;
                        delete this->callable;
                    }
                }
                DECAF_CATCHALL_NOTHROW()
            }
 
            virtual T call() {
                if (this->task != NULL) {
                    this->task->run();
                    return result;
                } else {
                    return this->callable->call();
                }
            }
        };
 
        class FutureTaskSync : public locks::AbstractQueuedSynchronizer {
        private:
 
            enum SyncState {
                READY = 0,
                RUNNING = 1,
                RAN = 2,
                CANCELLED = 4
            };
 
            Pointer< Callable<T> > callable;
 
            T result;
 
            Pointer<decaf::lang::Exception> exception;
 
            // The FutureTask parent of the Sync object.
            FutureTask* parent;
 
            decaf::lang::Thread* runner;
 
        private:
 
            FutureTaskSync(const FutureTaskSync&);
            FutureTaskSync operator= (const FutureTaskSync&);
 
        public:
 
            FutureTaskSync(FutureTask* parent, Callable<T>* callable) :
                AbstractQueuedSynchronizer(), callable(callable), result(), exception(), parent(parent), runner(NULL) {
            }
 
            virtual ~FutureTaskSync() {
            }
 
            bool innerIsCancelled() const {
                return getState() == CANCELLED;
            }
 
            bool innerIsDone() const {
                return ranOrCancelled(getState()) && this->runner == NULL;
            }
 
            T innerGet() {
                this->acquireSharedInterruptibly(0);
                if (getState() == CANCELLED) {
                    throw CancellationException();
                }
                if (exception != NULL) {
                    throw ExecutionException(exception->clone());
                }
                return result;
            }
 
            T innerGet(long long nanosTimeout) {
                if (!tryAcquireSharedNanos(0, nanosTimeout)) {
                    throw TimeoutException();
                }
                if (getState() == CANCELLED) {
                    throw CancellationException();
                }
                if (exception != NULL) {
                    throw ExecutionException(exception->clone());
                }
                return result;
            }
 
            void innerSet(const T& result) {
                for (;;) {
                    int s = getState();
                    if (s == RAN) {
                        return;
                    }
                    if (s == CANCELLED) {
                        // aggressively release to set runner to null,
                        // in case we are racing with a cancel request
                        // that will try to interrupt runner
                        releaseShared(0);
                        return;
                    }
                    if (compareAndSetState(s, RAN)) {
                        this->result = result;
                        releaseShared(0);
                        this->parent->done();
                        return;
                    }
                }
            }
 
            void innerSetException(const decaf::lang::Exception& t) {
                for (;;) {
                    int s = getState();
                    if (s == RAN) {
                        return;
                    }
                    if (s == CANCELLED) {
                        // aggressively release to set runner to null,
                        // in case we are racing with a cancel request
                        // that will try to interrupt runner
                        releaseShared(0);
                        return;
                    }
                    if (compareAndSetState(s, RAN)) {
                        exception.reset(t.clone());
                        releaseShared(0);
                        this->parent->done();
                        return;
                    }
                }
            }
 
            bool innerCancel(bool mayInterruptIfRunning) {
                for (;;) {
                    int s = getState();
                    if (ranOrCancelled(s)) {
                        return false;
                    }
                    if (compareAndSetState(s, CANCELLED)) {
                        break;
                    }
                }
 
                if (mayInterruptIfRunning) {
                    decaf::lang::Thread* r = runner;
                    if (r != NULL) {
                        r->interrupt();
                    }
                }
 
                releaseShared(0);
                this->parent->done();
                return true;
            }
 
            void innerRun() {
                if (!compareAndSetState(READY, RUNNING)) {
                    return;
                }
 
                this->runner = decaf::lang::Thread::currentThread();
                if (getState() == RUNNING) { // recheck after setting thread
                    T result;
                    try {
                        result = this->callable->call();
                    } catch(decaf::lang::Exception& ex) {
                        this->parent->setException(ex);
                        return;
                    } catch(std::exception& stdex) {
                        this->parent->setException(decaf::lang::Exception(new std::exception(stdex)));
                        return;
                    } catch(...) {
                        this->parent->setException(decaf::lang::Exception(
                            __FILE__, __LINE__, "FutureTask Caught Unknown exception during task execution."));
                        return;
                    }
                    this->parent->set(result);
                } else {
                    releaseShared(0); // cancel
                }
            }
 
            bool innerRunAndReset() {
                if (!compareAndSetState(READY, RUNNING)) {
                    return false;
                }
 
                try {
                    this->runner = decaf::lang::Thread::currentThread();
                    if (getState() == RUNNING) {
                        this->callable->call(); // don't set result
                    }
                    this->runner = NULL;
                    return compareAndSetState(RUNNING, READY);
                } catch(decaf::lang::Exception& ex) {
                    this->parent->setException(ex);
                    return false;
                } catch(std::exception& stdex) {
                    this->parent->setException(decaf::lang::Exception(new std::exception(stdex)));
                    return false;
                } catch(...) {
                    this->parent->setException(decaf::lang::Exception(
                        __FILE__, __LINE__, "FutureTask Caught Unknown exception during task execution."));
                    return false;
                }
            }
 
        protected:
 
            virtual int tryAcquireShared(int ignore DECAF_UNUSED) {
                return innerIsDone() ? 1 : -1;
            }
 
            virtual bool tryReleaseShared(int ignore DECAF_UNUSED) {
                runner = NULL;
                return true;
            }
 
        private:
 
            bool ranOrCancelled(int state) const {
                return (state & (RAN | CANCELLED)) != 0;
            }
        };
 
    private:
 
        Pointer<FutureTaskSync> sync;
 
    public:
 
        FutureTask(Callable<T>* callable, bool takeOwnership = true) : sync(NULL) {
            if (callable == NULL ) {
                throw decaf::lang::exceptions::NullPointerException(__FILE__, __LINE__,
                    "The Callable pointer passed to the constructor was NULL");
            }
 
            this->sync.reset(new FutureTaskSync(this, new FutureTaskAdapter(callable, takeOwnership)));
        }
 
        FutureTask(decaf::lang::Runnable* runnable, const T& result, bool takeOwnership = true) : sync(NULL) {
            if (runnable == NULL ) {
                throw decaf::lang::exceptions::NullPointerException(__FILE__, __LINE__,
                    "The Runnable pointer passed to the constructor was NULL");
            }
 
            this->sync.reset(new FutureTaskSync(this, new FutureTaskAdapter(runnable, result, takeOwnership)));
        }
 
        virtual ~FutureTask() {
        }
 
        virtual bool isCancelled() const {
            return this->sync->innerIsCancelled();
        }
 
        virtual bool isDone() const {
            return this->sync->innerIsDone();
        }
 
        virtual bool cancel(bool mayInterruptIfRunning) {
            return this->sync->innerCancel(mayInterruptIfRunning);
        }
 
        virtual T get() {
            return this->sync->innerGet();
        }
 
        virtual T get(long long timeout, const TimeUnit& unit) {
            return this->sync->innerGet(unit.toNanos(timeout));
        }
 
        FutureTask<T>* clone() {
            return new FutureTask<T>(*this);
        }
 
    public:
 
        virtual void done() {}
 
        virtual void set(const T& result) {
            this->sync->innerSet(result);
        }
 
        virtual void setException(const decaf::lang::Exception& error) {
            this->sync->innerSetException(error);
        }
 
        virtual void run() {
            this->sync->innerRun();
        }
 
        virtual bool runAndReset() {
            return this->sync->innerRunAndReset();
        }
 
    public:
 
        FutureTask(const FutureTask<T>& source) : RunnableFuture<T>(), sync(source.sync) {
        }
 
        FutureTask<T>& operator= (const FutureTask<T>& source) {
            this->sync = source.sync;
            return *this;
        }
 
    };
 
}}}
 
#endif /* _DECAF_UTIL_CONCURRENT_FUTURETASK_H_ */