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: