threadlock.h

Go to the documentation of this file.

#pragma once

/*
________________________________________________________________________

 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        Bert
 Date:          June 2013
________________________________________________________________________

*/

#include "basicmod.h"
#include "commondefs.h"
#include "plftypes.h"


namespace Threads
{
class Mutex;
class SpinLock;
class ReadWriteLock;

mExpClass(Basic) Lock
{
public:

    enum Type                   { BigWork, SmallWork, MultiRead };

                                Lock(bool for_just_a_few_operations=false);
                                Lock(Type);
                                Lock(const Lock&);
    Lock&                       operator =(const Lock&);
    virtual                     ~Lock();


    // For thread-specialists:
    inline bool                 isMutex() const         { return (bool)mutex_; }
    inline bool                 isSpinLock() const      { return (bool)splock_;}
    inline bool                 isRWLock() const        { return (bool)rwlock_;}
    inline Mutex&               mutex()                 { return *mutex_; }
    inline SpinLock&            spinLock()              { return *splock_; }
    inline ReadWriteLock&       readWriteLock()         { return *rwlock_; }

protected:

    Mutex*              mutex_;
    SpinLock*           splock_;
    ReadWriteLock*      rwlock_;

};


mExpClass(Basic) Locker
{
public:

    enum WaitType               { WaitIfLocked, DontWaitForLock };
    enum RWType                 { ReadLock, WriteLock };

                                // default = WaitIfLocked / ReadLock
                                Locker(Lock&);
                                Locker(Lock&,WaitType);
                                Locker(Lock&,RWType);
                                Locker(Lock&,WaitType,RWType);
                                Locker(Lock&,RWType,WaitType);
    virtual                     ~Locker()               { unlockNow(); }

    inline bool                 isLocked() const        { return needunlock_; }
                                //<! only useful if DontWaitForLock
    void                        unlockNow();
                                //<! to explicitly release earlier than the
    void                        reLock(WaitType wt=WaitIfLocked);
    bool                        convertToWriteLock();
                                //<! only interesting for MultiRead

protected:

     Lock&                      lock_;
     bool                       needunlock_;
     bool                       isread_;

private:

                                Locker(const Locker&);
    Locker&                     operator =(const Locker&);

};


mGlobal(Basic) bool lockSimpleSpinWaitLock(volatile int& lock);
mGlobal(Basic) bool lockSimpleSpinLock(volatile int& lock,Locker::WaitType);
mGlobal(Basic) void unlockSimpleSpinLock(volatile int& lock);


} // namespace Threads