pthread - thread c++ ejemplo

Seguridad de subprocesos y `const`

Question

¿Cómo ayuda const (punteros, referencias y funciones de miembro) con la seguridad de subprocesos en C ++?

Answer 1

Las funciones de Const no son seguras para hilos. Normalmente, puede llamar a los métodos del objeto const desde distintos subprocesos al mismo tiempo, pero si llama al método non const y const desde diferentes subprocesos, se obtiene la condición de anticipación. Mira esto:

class Foo
{
    size_t size_;
public:
    ...
    size_t get_size() const
    {
        return size_
    }
};

class Bar
{
    boost::shared_ptr<Foo> foo_;
public:
    //accessor
    size_t get_size() const
    {
        size_t size = 0;
        if (foo_)
            size = foo_->size();
        return size;
    }
    //modifiers
    void init()
    {
        foo_ = new Foo;
    }

    void clear()
    {
        foo_ = boost::shared_ptr<Foo>();
    }
};

Si alguien llama al método init, y luego llama a los métodos clear y get_size al mismo tiempo, se producirá una infracción de acceso. Debe usar el modismo de bloqueo de lectura y escritura. Se pueden llamar múltiples accesores al mismo tiempo, y solo se puede llamar a un modificador al mismo tiempo. Ejemplo:

class Bar
{
    boost::shared_ptr<Foo> foo_;
    mutable tbb::spin_rw_mutex lock_;
public:
    //accessor
    size_t get_size() const
    {
        size_t size = 0;
        //lock modifiers
        rw_mutex_type::scoped_lock lock(mutex, false);
        if (foo_)
            size = foo_->size();
        return size;
    }
    //modifiers
    void init()
    {
        //lock accessor and modifiers
        rw_mutex_type::scoped_lock lock(mutex, true);
        foo_ = new Foo;
    }

    void clear()
    {
        //lock accessor and modifiers
        rw_mutex_type::scoped_lock lock(mutex, true);
        foo_ = boost::shared_ptr<Foo>();
    }
};

tbb :: spin_rw_lock es una clase mutex de threading builing blocks library

Answer 2

Cualquier información inmutable (es decir, no modificable) es intrínsecamente segura para subprocesos: no hay riesgo de que varios subprocesos al mismo tiempo lean los mismos datos de solo lectura porque nunca va a cambiar.

Marcar una variable como const en C ++ la hace de solo lectura y, por lo tanto, es segura para las cadenas.

Answer 3

El principal problema con múltiples hilos es la mutabilidad. const restringe esto, pero ya que puedes descartar la const-ness, no es infalible.

Answer 4

Una función de miembro constante no debe cambiar el estado, lo que hace que sea seguro llamar desde múltiples hilos al mismo tiempo. Sin embargo, la seguridad de subprocesos no es el propósito de const y C ++ proporciona la palabra clave mutable y const_cast, lo que significa que const no garantiza la seguridad de subprocesos y no debe confiarse en ello.

Answer 5

C ++ const permite aliasing no const, como:

Foo myVar;
const Foo* ptr1;
Foo* ptr2;

Teniendo esto en cuenta, const no ofrece garantías en cuanto a la inmutabilidad de sus datos, incluso si usted no realiza ningún casting ni nada para evitarlo. Si accede myVar a través de ptr1, no puede cambiarlo a través de ptr1 (suponiendo que obtuve la sintaxis correcta; esa era la intención). Sin embargo, aún podría cambiar a través de ptr2. Lo que realmente quieres es una construcción inmutable separada. Esto no existe en C ++.

Answer 6

Const y thread safety son conceptos ortogonales.

Tomemos una función const como ejemplo: una clase puede tener tanto funciones const como no const, y un hilo puede estar llamando a una función non-const que modifica el objeto al mismo tiempo que otro hilo está en su función const. En este caso, marcar la función const no proporciona seguridad alguna. La seguridad de la rosca solo se logra con bloqueo u otras primitivas de sincronización.