UT/UT_DoubleLock.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Jeff Lait
 *      Side Effects Software Inc
 *      123 Front Street West, Suite 1401
 *      Toronto, Ontario
 *      Canada   M5J 2M2
 *      416-504-9876
 *
 * NAME:        UT_DoubleLock.h ( UT Library, C++)
 *
 * COMMENTS:
 */

#ifndef __UT_DoubleLock__
#define __UT_DoubleLock__

#include "UT_API.h"

#include "UT_Lock.h"

//
// A double-checked lock.  Only locks the thread lock when the value is 0.
// 
// This works similar to an AutoLock, but provides a needInit function
// to tell you if you val was false after locking
//
// To use this lock:
//
// UT_Lock      theLock;
//
// OBJECT *
// getSingleton()
// {
//      volatile static OBJECT *theObj = 0;
//
//      UT_DoubleLock<OBJECT *> lock(theLock, theObj);
//      
//      if (!lock.getValue())
//      {
//              lock.setValue(new OBJECT());
//      }
//      return lock.getValue();
// }
//
// NOTE: Do not roll your own double checked lock.  Double checked locks
// ideally need machine support to work properly - this implementation
// is theoritically broken.  The intent of this class is to make it
// easy to replace DoubleLock with an AutoLock equivalent, allowing
// us to time the cost of using AutoLocks and see if one of these odd
// cases is the source of multi threaded bugs.
//
// You are discouraged from using double checked locks.  Consider
// eager evaluation or thread local storage of the cached value
// as preferable alternatives.
//
template <class T>
class UT_DoubleLock
{
public:
     UT_DoubleLock(UT_Lock &lock, T &val)
         : myLock(lock)
         , myValue(val)
         , myPendingValue(0)
         , myIsLocked(false)
         , myNeedInit(false)
     {
         if (!val)
         {
             myLock.lock();
             myIsLocked = true;
             if (!val)
                 myNeedInit = true;
         }
     }
    
    ~UT_DoubleLock()
    {
        if (myIsLocked)
        {
            if (myNeedInit)
            {
                UT_ASSERT_P(myPendingValue);
                myValue = myPendingValue;
            }
            myLock.unlock();
        }
    }

    T            getValue()
    {
        if (myPendingValue)
            return myPendingValue;
        return myValue;
    }
    void         setValue(T val)
    {
        UT_ASSERT_P(myNeedInit);
        myPendingValue = val;
    }
    
private:
    UT_Lock     &myLock;
    T           &myValue;
    T            myPendingValue;
    bool         myIsLocked;
    bool         myNeedInit;
};

#endif

---