Mutex блокировка приватного поля класса

class A
{
private:
   Pixel** pixels;
   std::mutex door;
public:
   Pixel** GetPixels();
}

    class Bitmap
    {
        private:
            Pixel** pixels;
            Vector2 Size;
            mutex door;
 
        public:
            //= Конструкторы / Деструкторы ============================
            Bitmap();
            ~Bitmap();
            Bitmap(Vector2 size);
            Bitmap(Pixel** pixels);
            Bitmap(Byte* pixels, int bpp);
 
            //= Методы замены =========================================
            void SetPixel (const Vector2 position, const Pixel color);
            void SetPixels(Pixel** pixels);
            void SetBytes(Byte* Pixels, int bpp);
 
            //= Методы получения =======================================
            Pixel  GetPixel(Vector2 position);
            Pixel** GetPixels();
            Byte*   GetBytes(int bpp);
            Vector2 GetSize();
 
            //= Обработка Mutex ========================================
            bool closed = false;// флаг показывающий заблокированы ли ресурсы изображения
 
            void Lock()
            {
                closed = true;
                door.lock();
            }
            bool try_Lock()
            {
                return closed = door.try_lock();
            }
            void Unlock()
            {
                closed = false;
                door.unlock();
            }
 
    };

        void Binary::Build(Bitmap* face, float treshold)
        {
            // дожидаемся освобождения ресурсов.
            while(!face->try_Lock());
            // как только они освобождаются блокируем и забираем их для просчёта
            Pixel** pixels = face->GetPixels();
            Vector2 Size = face->GetSize();
 
            for(int x = 0; x < Size.x; x++)
            {
                for(int y = 0; y < Size.y; y++)
                {
                    if(pixels[x][y].GetBrightness() <  treshold)
                    {
                        pixels[x][y] = Pixel(0,0,0);
                    }
                    else
                    {
                        pixels[x][y] = Pixel(255,255,255);
                    }
                }
            }
            face->Unlock();// разблокирование после просчёта.
        }

void Bitmap::process_pixels(std::function<void(Pixel&)> i_process)
{
  std::lock_guard<std::mutex> lock(door);
 
  // дальше прежний цикл
  for(int x = 0; x < Size.x; x++)
  {
     for(int y = 0; y < Size.y; y++)
     {
        i_process(pixels[x][y]);
     }
  }
}

Pixel A::GetPixel(int x, int y)
{
    std::lock_guard<std::mutex> lock(door);
    return pixels[x][y];
}

std::pair<Pixel**, std::unique_lock<std::mutex>>&& A::GetPixels()
{
    typedef std::unique_lock<std::mutex> Lock;
    return std::move(std::pair<Pixel**, Lock>(pixels, Lock(door)));
}

template <class Func>
auto A::WithPixels(Func&& thunk) -> decltype(thunk(pixels)) {
    std::lock_guard<std::mutex> lock(door);
    return thunk(pixels);
}

        void Binary::Build(Bitmap* face, float treshold)
        {
            while(!face->try_lock());
            Pixel** pixels = face->GetPixels();
            Vector2 Size = face->GetSize();
 
            for(int x = 0; x < Size.x; x++)
            {
                for(int y = 0; y < Size.y; y++)
                {
                    if(pixels[x][y].GetBrightness() <  treshold)
                    {
                        pixels[x][y] = Pixel(0,0,0);
                    }
                    else
                    {
                        pixels[x][y] = Pixel(255,255,255);
                    }
                }
            }
            face->Unlock();
        }
 
 
        Binary::Binary(Bitmap* bitmap, float treshold)
        {
            thread th0(Build, bitmap, treshold);
            th0.detach();
        }