sync.h

Go to the documentation of this file.

// Copyright (C) 2012-2016 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#ifndef KEA_THREAD_SYNC_H
#define KEA_THREAD_SYNC_H

#include <exceptions/exceptions.h>

#include <boost/noncopyable.hpp>

#include <cstdlib> // for NULL.

namespace isc {
namespace util {
namespace thread {
class CondVar;

class Mutex : boost::noncopyable {
public:
    Mutex();

    ~Mutex();

    class Locker : boost::noncopyable {
    public:
        struct AlreadyLocked : public isc::InvalidParameter {
            AlreadyLocked(const char* file, size_t line, const char* what) :
                isc::InvalidParameter(file, line, what)
            {}
        };

        Locker(Mutex& mutex, bool block = true) :
            mutex_(mutex)
        {
            if (block) {
                mutex.lock();
            } else {
                if (!mutex.tryLock()) {
                    isc_throw(AlreadyLocked, "The mutex is already locked");
                }
            }
        }

        ~Locker() {
            mutex_.unlock();
        }
    private:
        Mutex& mutex_;
    };
    bool locked() const;

private:
    void lock();

    bool tryLock();

    void unlock();

private:
    friend class CondVar;

    // Commonly called after acquiring the lock, checking and updating
    // internal state for debug.
    //
    // Note that this method is only available when the build is
    // configured with debugging support.
    void postLockAction();

    // Commonly called before releasing the lock, checking and updating
    // internal state for debug.
    //
    // If throw_ok is true, it throws \c isc::InvalidOperation when the check
    // fails; otherwise it aborts the process.  This parameter must be set
    // to false if the call to this shouldn't result in an exception (e.g.
    // when called from a destructor).
    //
    // Note that this method is only available when the build is
    // configured with debugging support.
    void preUnlockAction(bool throw_ok);

    class Impl;
    Impl* impl_;
};

class CondVar : boost::noncopyable {
public:
    CondVar();

    ~CondVar();

    void wait(Mutex& mutex);

    void signal();
private:
    class Impl;
    Impl* impl_;
};

} // namespace thread
} // namespace util
} // namespace isc

#endif

// Local Variables:
// mode: c++
// End: