Что такое мьютекс

Что такое мьютекс

Евдокимов А.А., Майстренко Н.В., Майстренко А.В.

3.3.5. Мьютексы

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

Мьютекс — это совместно используемая переменная, которая может находиться в одном из двух состояний: заблокированном или незаблокированном. Следовательно, для их представления нужен только один бит, но на практике зачастую используется целое число, при этом нуль означает незаблокированное, а все остальные значения — заблокированное состояние. Для работы с мьютексами используются две процедуры. Когда потоку (или процессу) необходим доступ к критической области, он вызывает процедуру mutex_lock. Если мьютекс находится в незаблокированном состоянии (означающем доступность входа в критическую область), вызов проходит удачно и вызывающий поток может свободно войти в критическую область.

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

В листинге 3.3 показан код процедур mutex_lock и mutex_unlock, предназначенных для использования в совокупности потоков, работающих в пользовательском пространстве.

Листинг 3.3.Реализация mutexjock и mutex_unlock mutex_lock:

TSL REGISTER,MUTEX | копирование мьютекса в регистр и установка его в 1 CMP REGISTER,#0 | был ли мьютекс нулевым? JZE ok | если он был нулевым, значит, не был заблокирован,поэтому | нужно вернуть управление вызывающей программе CALL thread_yield | мьютекс занят; пусть планировщик возобновит работу другого потока JMP mutex lock | повторная попытка ok: RET | возврат управления вызывающей программе; |будет осуществлен вход в критическую область mutex_unlock: MOVE MUTEX,#0 | сохранение в мьютексе значения 0 RET | возврат управления вызывающей программе





 

Код процедуры mutex_lock похож на код enter_region в листинге 3.1, но с одной существенной разницей. Когда процедуре enter_region не удается войти в критическую область, она продолжает повторное тестирование значения переменной lock (выполняет активное ожидание). По истечении определенного времени планировщик возобновляет работу какого-нибудь другого процесса. Рано или поздно возобновляется работа процесса, удерживающего блокировку, и он ее освобождает.

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

Вот в этом и заключается разница между enter_region и mutex_lock. Когда последняя из этих процедур не может завладеть блокировкой, она вызывает процедуру thread_ yield, чтобы уступить центральный процессор другому потоку. Следовательно, активное ожидание отсутствует. Когда поток в очередной раз возобновит свою работу, он снова проверяет состояние блокировки.

Что такое мьютекс

Еще один инструмент управления синхронизацией потоков представляет класс Mutex или мьютекс, который также располагается в пространстве имен System.Threading .

Так, возьмем пример с оператором lock из одной из предыдущих тем, в котором применялась синхронизация потоков:

int x = 0; object locker = new(); // объект-заглушка // запускаем пять потоков for (int i = 1; i < 6; i++) < Thread myThread = new(Print); myThread.Name = $"Поток "; myThread.Start(); > void Print() < lock (locker) < x = 1; for (int i = 1; i < 6; i++) < Console.WriteLine($": "); x++; Thread.Sleep(100); > > >

И перепишем данный пример, используя мьютексы:

int x = 0; Mutex mutexObj = new(); // запускаем пять потоков for (int i = 1; i < 6; i++) < Thread myThread = new(Print); myThread.Name = $"Поток "; myThread.Start(); > void Print() < mutexObj.WaitOne(); // приостанавливаем поток до получения мьютекса x = 1; for (int i = 1; i < 6; i++) < Console.WriteLine($": "); x++; Thread.Sleep(100); > mutexObj.ReleaseMutex(); // освобождаем мьютекс >

Сначала создаем объект мьютекса:

Mutex mutexObj = new Mutex()

Основную работу по синхронизации выполняют методы WaitOne() и ReleaseMutex() . Метод mutexObj.WaitOne() приостанавливает выполнение потока до тех пор, пока не будет получен мьютекс mutexObj.

Изначально мьютекс свободен, поэтому его получает один из потоков.

После выполнения всех действий, когда мьютекс больше не нужен, поток освобождает его с помощью метода mutexObj.ReleaseMutex() . А мьютекс получает один из ожидающих потоков.

Таким образом, когда выполнение дойдет до вызова mutexObj.WaitOne() , поток будет ожидать, пока не освободится мьютекс. И после его получения продолжит выполнять свою работу.

[C++] часть 2: МЬЮТЕКС. Пишем наш первый код для многопоточной среды

Научитесь создавать код для использования в многопоточной среде с помощью реализации потокобезопасной очереди

Published in

NOP::Nuances of Programming

8 min read
Nov 30, 2019

В прошлой статье мы разобрались с тем, что такое конкурентность/параллелизм и зачем нужна синхронизация. Настала пора изучить примитивы синхронизации, которые предлагает нам стандартная библиотека шаблонов C++.

Первым из них будет std::mutex . Но сначала ознакомьтесь с картой статьи (она пригодится, если вы вдруг запутаетесь).

Что такое мьютекс?

Мьютекс (англ. mutex, от mutual exclusion — «взаимное исключение») — это базовый механизм синхронизации. Он предназначен для организации взаимоисключающего доступа к общим данным для нескольких потоков с использованием барьеров памяти (для простоты можно считать мьютекс дверью, ведущей к общим данным).

Синтаксис

• Заголовочный файл | #include
• Объявление | std::mutex mutex_name;
• Захват мьютекса | mutex_name.lock();
  Поток запрашивает монопольное использование общих данных, защищаемых мьютексом. Дальше два варианта развития событий: происходит захват мьютекса этим потоком (и в этом случае ни один другой поток не сможет получить доступ к этим данным) или поток блокируется (если мьютекс уже захвачен другим потоком).
• Освобождение мьютекса | mutex_name.unlock();
  Когда ресурс больше не нужен, текущий владелец должен вызвать функцию разблокирования unlock, чтобы и другие потоки могли получить доступ к этому ресурсу. Когда мьютекс освобождается, доступ предоставляется одному из ожидающих потоков.

#include 
#include std::mutex door; // объявление мьютекса
std::vector v; // общие данные door.lock();
/*-----------------------*/ /* Это потокобезопасная зона: допускается только один поток за раз 
* 
 * Гарантируется монопольное использование вектора v 
*/ /*-----------------------*/
door.unlock();

#include 
#include 

class threadSafe_queue  
std::queue rawQueue; // структура, общая для всех потоков 
std::mutex m; // красная дверь rawQueue

public:
 
int& retrieve_and_delete() int front_value = 0; // если пустая, возвращает 0 
m.lock(); 
// Отныне текущий поток единственный, который имеет доступ к rawQueue 
if( !rawQueue.empty() ) front_value = rawQueue.front(); 
rawQueue.pop(); 
> 
m.unlock(); 
// теперь другие потоки могут захватить мьютекс 
return front_value; 
>;
 
void push(int val) m.lock(); 
rawQueue.push(val); 
m.unlock(); 
>;

>;

#include 
#include std::mutex door; // объявление мьютекса
std::vector v;  
std::lock_guard lg(door); 
/* Вызывается конструктор lg, эквивалентный door.lock(); 
* lg, размещается в стеке */ 
/*-----------------------*/ 
 
/* Гарантируется монопольное использование вектора v */ 
 
/*-----------------------*/> /* lg выходит из области видимости. Вызывается деструктор, эквивалентный door.unlock(); */

#include 
#include 

class threadSafe_queue  
std::queue rawQueue; // структура, общая для всех потоков 
std::mutex m; // красная дверь rawQueue

public:
 
int& retrieve_and_delete() int front_value = 0; // если пустая, return будет 0 
std::lock_guard lg(m); 
// Отныне текущий поток единственный, который имеет доступ к rawQueue 
if( !rawQueue.empty() ) front_value = rawQueue.front(); 
rawQueue.pop(); 
> 
return front_value; 
>; // теперь другие потоки могут захватить мьютекс
 
void push(int val) std::lock_guard lg(m); 
// отныне текущий поток единственный, который имеет доступ к rawQueue 
rawQueue.push(val); 
>; // теперь другие потоки могут захватить мьютекс
>;

#include 
#include 
std::mutex door; //объявление мьютекса
std::vector v; < 
std::unique_lock ul(door); 
// Вызывается конструктор ul, эквивалентный door.lock(); 
// ul, размещённый в стеке 
// гарантируется монопольное использование вектора 
 
door.unlock(); 
 
// выполнение операций, не связанных с вектором 
// . 
// теперь мне снова нужен доступ к вектору 
 
door.lock(); 
//Снова гарантируется монопольное использование вектора> /* unique_lock выходит из области видимости. Вызывается деструктор, эквивалентный door.unlock(); */

#include 
#include std::shared_mutex door; //объявление мьютекса
std::vector v;int readVectorSize() /* потоки могут вызывать эту функцию одновременно 
* доступ на запись запрещена, когда получен sl */ 
 
std::shared_lock sl(door); 
return v.size();>
void pushElement(int new_element) /* гарантирован эксклюзивный доступ к вектору */ 
 
std::unique_lock ul(door); 
v.push_back(new_element);
>