то можно вызвать функцию x.detach(). После этого у нас не будет возможности управлять потоком. Независимо от принятого решения, мы должны всегда объединять или откреплять потоки. Если мы не сделаем этого, то деструктор объекта thread вызовет функцию std::terminate(), что приведет к внезапному завершению работы приложения.

В момент, когда функция main возвращает значение, приложение заканчивает работу. Однако в это же время наш открепленный поток t3 все еще находится в приостановленном состоянии и не успевает отправить сообщение bye на консоль. Операционной системе это неважно: она просто завершает всю программу, не дожидаясь завершения данного потока. Указанный факт важно иметь в виду. Если дополнительный поток должен был соревноваться за что-то важное, то нужно было бы подождать его завершения в функции main. 

Выполняем устойчивую к исключениям общую блокировку с помощью td::unique_lock и std::shared_lock

Поскольку работа потоков значительно зависит от поддержки операционной системы, а STL предоставляет хорошие интерфейсы, позволяющие абстрагироваться от операционных систем, разумно также предоставить поддержку STL для синхронизации между потоками. Таким образом, можно не только запускать и останавливать потоки без внешних библиотек, но и синхронизировать их с помощью абстракций из одной объединенной библиотеки — STL.

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

Как это делается

В этом примере мы напишем программу, которая использует экземпляр класса std::shared_mutex в эксклюзивном и коллективном режимах, и увидим, что это значит. Кроме того, не будем вызывать функции lock и unlock самостоятельно, а сделаем это с помощью вспомогательных функций RAII.

1. Сначала включим все необходимые заголовочные файлы. Поскольку мы задействуем функции и структуры данных STL, а также временные литералы, объявим об использовании пространств имен std и chrono_literal:

#include <iostream>

#include <shared_mutex>

#include <thread>

#include <vector>

using namespace std;

using namespace chrono_literals;

2. Вся программа строится вокруг одного общего мьютекса, поэтому для простоты объявим его глобальный экземпляр:

shared_mutex shared_mut;

3. Мы будем использовать вспомогательные функции RAII std::shared_lock и std::unique_lock. Чтобы их имена выглядели более понятными, определим для них короткие псевдонимы:

using shrd_lck = shared_lock<shared_mutex>;

using uniq_lck = unique_lock<shared_mutex>;

4. Прежде чем начнем писать функцию main, определим две вспомогательные функции, которые пытаются заблокировать мьютекс в эксклюзивном режиме. Эта функция создаст экземпляр класса unique_lock для общего мьютекса. Второй аргумент конструктора defer_lock указывает объекту поддерживать блокировку снятой. В противном случае его конструктор попробует заблокировать мьютекс, а затем будет удерживать его до завершения. Далее вызываем метод try_lock для объекта exclusive_lock. Этот вызов немедленно вернет булево значение, которое говорит, получили мы блокировку или же мьютекс уже был заблокирован кем-то еще.

static void print_exclusive()

{

  uniq_lck l {shared_mut, defer_lock};

  if (l.try_lock()) {

    cout << "Got exclusive lock.n";

  } else {

    cout << "Unable to lock exclusively.n";

  }

}

5. Другая вспомогательная функция также пытается заблокировать мьютекс в эксклюзивном режиме. Она делает это до тех пор, пока не получит блокировку. Затем мы симулируем какую-нибудь ошибку, генерируя исключение (содержащее лишь простое целое число). Несмотря на то, что это приводит к мгновенному выходу контекста, в котором мы хранили заблокированный мьютекс, последний будет освобожден. Это происходит потому, что деструктор объекта unique_lock освободит блокировку в любом случае по умолчанию.

static void exclusive_throw()

{

  uniq_lck l {shared_mut};

  throw 123;

}

6. Теперь перейдем к функции main. Сначала откроем еще одну область видимости и создадим экземпляр класса shared_lock. Его конструктор мгновенно заблокирует мьютекс в коллективном режиме. Мы увидим, что это значит, в следующих шагах.

int main()

{

  {

    shrd_lck sl1 {shared_mut};

    cout << "shared lock once.n";

7. Откроем еще одну область видимости и создадим второй экземпляр типа shared_lock для того же мьютекса. Теперь у нас есть два экземпляра типа shared_lock, и оба содержат общую блокировку мьютекса. Фактически можно создать произвольно большое количество экземпляров типа shared_lock для одного мьютекса. Затем вызываем функцию print_exclusive, которая пытается заблокировать мьютекс в эксклюзивном режиме. Эта операция не увенчается успехом, поскольку он уже находится в коллективном режиме.

    {

      shrd_lck sl2 {shared_mut};

      cout << "shared lock twice.n";

      print_exclusive();

    }

8. После выхода из самой поздней области видимости деструктор объекта sl2 типа shared_lock освобождает свою общую блокировку мьютекса. Функция print_exclusive снова даст сбой, поскольку мьютекс все еще находится в коллективном режиме блокировки.

    cout << "shared lock once again.n";

    print_exclusive();

  }

  cout << "lock is free.n";

9. После выхода из второй области видимости все объекты типа shared_lock подвергнутся уничтожению и мьютекс снова будет находиться в разблокированном состоянии. Теперь наконец можно заблокировать мьютекс в эксклюзивном режиме. Сделаем это путем вызовов exclusive_throw и print_exclusive. Помните, что мы генерируем исключение в вызове exclusive_throw. Но поскольку unique_lock — это объект RAII, который помогает защититься от исключений, мьютекс снова будет разблокирован независимо от того, что вернет вызов exclusive_throw. Таким образом, функция print_exclusive не будет ошибочно блокировать все еще заблокированный мьютекс:

    try {

      exclusive_throw();

    } catch (int e) {

    cout << "Got exception " << e << 'n';

  }

  print_exclusive();

}

10. Компиляция и запуск программы дадут следующий результат. Первые две строки показывают наличие двух экземпляров общей блокировки. Затем функция print_exclusive дает сбой при попытке заблокировать мьютекс в эксклюзивном режиме. После того как мы покинем внутреннюю область видимости и разблокируем вторую общую блокировку, функция print_exclusive все еще будет давать сбой. После выхода из второй области видимости, что наконец снова освободит мьютекс, функции exclusive_throw и print_exclusive смогут заблокировать мьютекс:

$ ./shared_lock

shared lock once.

shared lock twice.

Unable to lock exclusively.

shared lock once again.

Unable to lock