Eu tenho uma classe de thread da qual eu gostaria de ocasionalmente adquirir um ponteiro uma variável de instância. Eu gostaria que esse acesso fosse protegido por um mutex para que o thread fosse impedido de acessar esse recurso até que o cliente terminasse com seu ponteiro.

Minha abordagem inicial para isso é retornar um par de objetos: um um ponteiro para o recurso e um shared_ptr para um objeto de bloqueio no mutex. Esse shared_ptr contém a única referência ao objeto de bloqueio, portanto, o mutex deve ser desbloqueado quando sair do escopo. Algo assim:

void A::getResource()
{
    Lock* lock = new Lock(&mMutex);
    return pair<Resource*, shared_ptr<Lock> >(
        &mResource, 
        shared_ptr<Lock>(lock));
}

Essa solução é menos que ideal porque exige que o cliente mantenha o par inteiro de objetos. Comportamento como este quebra a segurança do segmento:

Resource* r = a.getResource().first;

Além disso, a minha própria implementação deste é um impasse e estou tendo dificuldade em determinar o porquê, então pode haver outras coisas erradas com isso.

O que eu gostaria de ter é um shared_ptr que contenha o bloqueio como uma variável de instância, vinculando-o aos meios para acessar o recurso. Isso parece algo que deve ter um padrão de design estabelecido, mas, depois de fazer algumas pesquisas, fico surpreso ao descobrir que é difícil encontrá-lo.

Minhas perguntas são:

Existe uma implementação comum desse padrão?Há problemas em colocar um mutex dentro de um shared_ptr que estou negligenciando que impede que esse padrão seja difundido?Existe uma boa razão para não implementar minha própria classe shared_ptr para implementar esse padrão?

(NB Estou trabalhando em uma base de código que usa Qt, mas infelizmente não pode usar boost neste caso. No entanto, as respostas que envolvem boost ainda são de interesse geral.)