AbstractQueuedSynchronizer.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_LOCKS_ABSTRACTQUEUEDSYNCHRONIZER_H_
#define _DECAF_UTIL_CONCURRENT_LOCKS_ABSTRACTQUEUEDSYNCHRONIZER_H_

#include <decaf/util/Config.h>

#include <decaf/util/concurrent/locks/AbstractOwnableSynchronizer.h>
#include <decaf/util/concurrent/locks/Condition.h>
#include <decaf/util/Collection.h>
#include <decaf/lang/Thread.h>

namespace decaf {
namespace util {
namespace concurrent {
namespace locks {

    class SynchronizerState;

    class DECAF_API AbstractQueuedSynchronizer : public AbstractOwnableSynchronizer {
    private:

        SynchronizerState* impl;

    private:

        AbstractQueuedSynchronizer(const AbstractQueuedSynchronizer&);
        AbstractQueuedSynchronizer& operator= (const AbstractQueuedSynchronizer&);

    protected:

        AbstractQueuedSynchronizer();

    public:

        class ConditionObject : public Condition {
        private:

            friend class AbstractQueuedSynchronizer;

        private:

            ConditionObject(const ConditionObject&);
            ConditionObject& operator= (const ConditionObject&);

        public:

            ConditionObject() : Condition() {}
            virtual ~ConditionObject() {}

        protected:

            virtual bool isOwnedBy(const AbstractQueuedSynchronizer* sync) const = 0;

            virtual bool hasWaiters() const = 0;

            virtual int getWaitQueueLength() const = 0;

            virtual Collection<decaf::lang::Thread*>* getWaitingThreads() const = 0;
        };

    public:

        virtual ~AbstractQueuedSynchronizer();

        void acquire(int arg);

        void acquireShared(int arg);

        void acquireInterruptibly(int arg);

        void acquireSharedInterruptibly(int arg);

        Collection<decaf::lang::Thread*>* getExclusiveQueuedThreads() const;

        Collection<decaf::lang::Thread*>* getSharedQueuedThreads() const;

        decaf::lang::Thread* getFirstQueuedThread() const;

        Collection<decaf::lang::Thread*>* getQueuedThreads() const;

        int getQueueLength() const;

        Collection<decaf::lang::Thread*>* getWaitingThreads(const AbstractQueuedSynchronizer::ConditionObject* condition) const;

        int getWaitQueueLength(const AbstractQueuedSynchronizer::ConditionObject* condition) const;

        bool hasContended() const;

        bool hasQueuedThreads() const;

        bool hasWaiters(const AbstractQueuedSynchronizer::ConditionObject* condition) const;

        bool isQueued(decaf::lang::Thread* thread) const;

        bool owns(const AbstractQueuedSynchronizer::ConditionObject* condition) const;

        bool release(int arg);

        bool releaseShared(int arg);

        std::string toString() const;

        bool tryAcquireNanos(int arg, long long nanos);

        bool tryAcquireSharedNanos(int arg, long long nanos);

    protected:

        virtual int getState() const;

        virtual void setState(int value);

        virtual bool compareAndSetState(int expect, int update);

        virtual bool isHeldExclusively() const;

        virtual bool tryAcquire(int arg);

        virtual int tryAcquireShared(int arg);

        virtual bool tryRelease(int arg);

        virtual bool tryReleaseShared(int arg);

        virtual ConditionObject* createDefaultConditionObject();

        bool hasQueuedPredecessors() const;

        friend class SynchronizerState;
    };

}}}}

#endif /* _DECAF_UTIL_CONCURRENT_LOCKS_ABSTRACTQUEUEDSYNCHRONIZER_H_ */