Как правильно использовать мьютекс?
У меня есть класс mailBox с методами отправки и получения, общими для потоков и потоков: поток 1 отправляет сообщение, потоки 2 и 3 получают сообщения, как я должен использовать мьютекс для синхронизации?
Любые комбинации, которые я пробовал, не привели к успеху.
std::mutex g_lock; //in global
void sendMessage(Message msg) {
if (g_lock.try_lock()) {
this_thread::sleep_for(100ms); // DELAY
messages->push_back(msg);
g_lock.unlock();
}
}
То же самое для метода получения
полный код: https://pastebin.com/7y2RC5br
Также этот код нельзя отлаживать, потому что задержки меняют логику кода.
Правильная логика кода: thread2/3 попробуйте заблокировать и прочитать сообщение, очистить, а затем разблокировать thread1 попробуйте заблокировать и отправить сообщение, затем разблокировать thread2/3 попробуйте заблокировать и прочитать сообщение, получить сообщение и записать в файл, затем разблокировать
Когда я пробовал try_lock мьютекса из потоков 2/3, у меня постоянно блокировался поток, а поток 1 работал после ВСЕХ потоков 2/3.
с try_lock, если блокировка не получена, вы не будете отправлять сообщения.
Но почему блокировку нельзя получить?
Вы должны решить, можете ли вы позволить себе НЕ блокировку или нет. Вам нужно использовать lock() вместо try_lock() в определенных ситуациях.
Ре. "But why lock can't be acquired?": предположительно, потому что он уже принадлежит другому потоку? Вам действительно нужно предоставить минимальный воспроизводимый пример, который демонстрирует проблему.
Отвечает ли это на ваш вопрос? std::unique_lock<std::mutex> или std::lock_guard<std::mutex>?
Ответы 1
Объедините мьютексы низкого уровня в типы стандартных блоков.
Потокобезопасность на основе блокировки смехотворно легко ошибиться. Он не только хрупок, он не сочиняет; три подпрограммы, которые попарно потокобезопасны, могут быть небезопасными при объединении.
Потокобезопасность — это относительное свойство, а не абсолютное.
Существуют различные известные шаблоны, работа которых математически доказана. Реализовано правильно, и вы менее обречены. Смешайте что-нибудь, и ваш код не будет правильным.
Чтобы разработать новый многопоточный код, вам нужно хорошо разбираться в информатике, основанной на доказательствах. Реализация проще, чем ее правильное проектирование.
В вашем случае я бы начал с потокобезопасного примитива очереди. Вам понадобятся условные переменные, мьютексы и стандартная двухсторонняя очередь. Затем подключите каждую подпрограмму к одному концу очереди и отправьте сообщения на другой конец. (Читатель должен только читать из очереди и потреблять каждое сообщение по порядку; писатель должен отправлять сообщения только в очередь).
Я имею в виду, что это все еще будет трудно сделать правильно, но, по крайней мере, ваши примитивы не являются необработанными мьютексами.
template<class T>
struct threadsafe_queue {
T pop();
void push(T);
std::deque<T> pop_all();
std::optional<T> try_pop();
template<class...Ts>
std::optional<T> wait_for_pop( std::chrono::duration<Ts...> );
private:
mutable std::mutex m;
std::condition_variable cv;
std::deque<T> queue;
std::unique_lock<std::mutex> lock() const;
};
Я начал использовать unique_lock с condition_variable, и это работает намного лучше, чем только один мьютекс.
Вы должны использовать std::lock_guard.`