Impulsionar shared_ptr questão contentor

Question

Vamos dizer que eu tenho um recipiente (std :: vector) de ponteiros usados ??por uma aplicação multi-threaded. Ao adicionar novos ponteiros para o contêiner, o código é protegido usando uma seção crítica (boost :: mutex). Tudo muito bem. O código deve ser capaz de voltar um desses ponteiros para uma linha de processamento, mas outro segmento separado pode optar por excluir um desses ponteiros, que ainda pode estar em uso. por exemplo:.

thread1()
{
    foo* p = get_pointer();
    ...
    p->do_something();
}

thread2()
{
    foo* p = get_pointer();
    ...
    delete p;
}

Assim thread2 poderia excluir o ponteiro enquanto thread1 está usando. Desagradável.

Então, ao invés eu quero usar um recipiente de aumento compartilhada PTR. IIRC estes ponteiros será referência contada, por isso, enquanto eu voltar ptrs compartilhados em vez de ponteiros crus, removendo-o da embalagem realmente não vai liberá-lo até o último uso dele sai do escopo. i.

std::vector<boost::shared_ptr<foo> > my_vec;

thread1()
{
    boost::shared_ptr<foo> sp = get_ptr[0];
    ...
    sp->do_something();
}

thread2()
{
    boost::shared_ptr<foo> sp = get_ptr[0];
    ...
    my_vec.erase(my_vec.begin());
}

boost::shared_ptr<foo> get_ptr(int index)
{
    lock_my_vec();
    return my_vec[index];
}

No exemplo acima, se thread1 recebe o ponteiro antes thread2 chamadas apagar, será o objeto apontado ainda ser válido? Não serão realmente excluídos quando Thread1 concluída? Nota que o acesso ao vetor global será através de uma seção crítica.

Eu acho que esta é a forma como shared_ptrs trabalhar, mas eu preciso ter certeza.

Answer 1

Para a segurança de threading de boost :: shared_ptr você deve verificar este link . Não é garantido para ser seguro, mas em muitas plataformas funciona. Modificando o std :: vector não é seguro AFAIK.

Answer 2

No exemplo acima, se thread1 recebe o ponteiro antes thread2 chamadas apagar, será o objeto apontado ainda ser válido? Não serão realmente excluídos quando Thread1 concluída?

No seu exemplo, se thread1 recebe o ponteiro antes thread2, então thread2 terá que esperar no início da função (por causa do bloqueio). Então, sim, o objeto apontado ainda será válido. No entanto, você pode querer se certificar de que my_vec não está vazia antes de acessar o seu primeiro elemento.

Answer 3

Se, além disso, você sincronizar os acessos ao vetor (como em sua proposta ponteiro bruto original), o seu uso é seguro. Caso contrário, você pode cair falta do exemplo 4 no link fornecido pelo outro entrevistado.