Означает ли const потокобезопасность в С++ 11?

Я слышал, что const означает потокобезопасный в C++11. Это правда?

Это отчасти верно...

Вот что говорит Standard Language о безопасности потоков:

[1.10/4] Два вычисления выражения конфликтуют, если одно из них изменяет ячейку памяти (1.7), а другое обращается к одному и тому же или изменяет его место памяти.

[1.10/21] Выполнение программы содержит гонку данных, если она содержит два конфликтующих действия в разных потоках, хотя бы одно из которых не является атомарным, и ни одно из них не происходит раньше другого. Любая такая гонка данных приводит к неопределенному поведению.

что является не чем иным, как достаточным условием для возникновения гонки данных:

1. Над данной вещью одновременно выполняются два или более действия; и
2. По крайней мере, один из них является записью.

Стандартная библиотека основывается на этом и идет немного дальше:

[17.6.5.9/1] В этом разделе указаны требования, которым должны соответствовать реализации для предотвращения гонки данных (1.10). Каждая стандартная библиотечная функция должна соответствовать каждому требованию, если не указано иное. Реализации могут предотвращать гонки данных в случаях, отличных от указанных ниже.

[17.6.5.9/3] Функция стандартной библиотеки C++ не должна прямо или косвенно изменять объекты (1.10), доступные для потоков, отличных от текущего потока, если к объектам не осуществляется прямой доступ или косвенно через не константные аргументы функции, включая this.

который простыми словами говорит, что он ожидает, что операции с const объектами будут поточно-ориентированными. Это означает, что в Стандартной библиотеке не будет гонки за данными, если также будут выполняться операции с const объектами ваших собственных типов.

1. Состоят полностью из операций чтения, т. е. без операций записи; или
2. Внутренне синхронизирует записи.

Если это ожидание не выполняется для одного из ваших типов, то его прямое или косвенное использование вместе с любым компонентом Стандартной библиотеки может привести к гонке данных. В заключение, const означает поточно-безопасный с точки зрения Стандартной библиотеки. Важно отметить, что это всего лишь контракт, и он не будет применяться компилятором, если вы нарушите его, вы получите неопределенное поведение, и вы предоставлены сами себе. . Присутствует ли const или нет, это не повлияет на генерацию кода — по крайней мере, не в отношении гонок данных—.

Означает ли это, что const теперь эквивалентно synchronized в Java?

Нет. Нисколько...

Рассмотрим следующий чрезмерно упрощенный класс, представляющий прямоугольник:

class rect {
    int width = 0, height = 0;

public:
    /*...*/
    void set_size( int new_width, int new_height ) {
        width = new_width;
        height = new_height;
    }
    int area() const {
        return width * height;
    }
};

Функция-член area является поточно-ориентированной; не потому, что это const, а потому, что он полностью состоит из операций чтения. Записи не выполняются, и хотя бы одна операция записи необходима для возникновения гонки данных. Это означает, что вы можете вызывать area из любого количества потоков, и вы всегда будете получать правильные результаты.

Обратите внимание, что это не означает, что rect является поточно-ориентированным. На самом деле легко увидеть, как если бы вызов area происходил одновременно с вызовом set_size для заданного rect, тогда area мог бы в конечном итоге вычислить свой результат на основе старой ширины и новой высоты (или даже по искаженным значениям).

Но это нормально, rect не const, так что в конце концов даже не ожидается, что он будет поточно-ориентированным. С другой стороны, объект, объявленный const rect, будет поточно-ориентированным, поскольку запись невозможна (и если вы рассматриваете возможность const_cast-объявления чего-то, изначально объявленного const, вы получите undefined-behavior< /em> и все).

class rect {
    int width = 0, height = 0;

    mutable int cached_area = 0;
    mutable bool cached_area_valid = true;

public:
    /*...*/
    void set_size( int new_width, int new_height ) {
        cached_area_valid = ( width == new_width && height == new_height );
        width = new_width;
        height = new_height;
    }
    int area() const {
        if( !cached_area_valid ) {
            cached_area = width;
            cached_area *= height;
            cached_area_valid = true;
        }
        return cached_area;
    }
};

class rect {
    int width = 0, height = 0;

    mutable std::mutex cache_mutex;
    mutable int cached_area = 0;
    mutable bool cached_area_valid = true;

public:
    /*...*/
    void set_size( int new_width, int new_height ) {
        if( new_width != width || new_height != height )
        {
            std::lock_guard< std::mutex > guard( cache_mutex );
        
            cached_area_valid = false;
        }
        width = new_width;
        height = new_height;
    }
    int area() const {
        std::lock_guard< std::mutex > guard( cache_mutex );
        
        if( !cached_area_valid ) {
            cached_area = width;
            cached_area *= height;
            cached_area_valid = true;
        }
        return cached_area;
    }
};