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
 RCS:           $Id$
________________________________________________________________________
 
*/
 
#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