Locking shared resources in constructor and destructor
===

I believe I've got a good handle on at least the basics of multi-threading in C++, but I've never been able to get a clear answer on locking a mutex around shared resources in the constructor or the destructor.  I was under the impression that you should lock in both places, but recently coworkers have disagreed.  Pretend the following class is accessed by multiple threads:

    class TestClass
    {
    public:
    
       TestClass(const float input) :
          mMutex(),
          mValueOne(1),
          mValueTwo("Text")
       {
          //**Does the mutex need to be locked here?
          mValueTwo.Set(input);
          mValueOne = mValueTwo.Get();
       }
    
       ~TestClass() 
       { 
         //Lock Here?
       }
    
       int GetValueOne() const
       {
          Lock(mMutex);
          return mValueOne;
       }

       void SetValueOne(const int value)
       {
          Lock(mMutex);
          mValueOne = value;
       }
   
       CustomType GetValueTwo() const
       {
          Lock(mMutex);
          return mValueOne;
       }

       void SetValueTwo(const CustomType type)
       {
          Lock(mMutex);
          mValueTwo = type;
       }

    private:

       Mutex mMutex;
       int mValueOne;
       CustomType mValueTwo;
    };

Of course everything should be safe through the initialization list, but what about the statements inside the constructor?  In the destructor would it be beneficial to do a non-scoped lock, and never unlock (essentially just call pthread_mutex_destroy)?