Внедрение высокоэффективного мьютекса, аналогичного Qt one

Ответ 1

Общие советы

Как уже упоминалось в некоторых комментариях, я бы сначала посмотрел, можете ли вы реструктурировать свой дизайн программы, чтобы сделать реализацию мьютекса менее критичной для вашей производительности.
Кроме того, поскольку поддержка многопоточности в стандартном С++ является довольно новой и немного инфантильной, вам иногда просто приходится возвращаться к специфичным для платформы механизмам, таким как, например, a futex в системах Linux или критических разделах в окнах или нестандартных библиотеках, таких как Qt.
При этом я мог бы подумать о двух подходах к реализации, которые могут потенциально ускорить вашу программу:

SpinLock
Если конфликты доступа происходят очень редко, и мьютекс удерживается только на короткие промежутки времени (две вещи, к которым нужно стремиться, конечно же), может быть наиболее эффективным просто использовать спин-блокировку, так как она не требует какой-либо системы звонки вообще и его просто реализовать (взято из cppreference):

class SpinLock {
    std::atomic_flag locked ;
public:
    void lock() {
        while (locked.test_and_set(std::memory_order_acquire)) { 
             std::this_thread::yield(); //<- this is not in the source but might improve performance. 
        }
    }
    void unlock() {
        locked.clear(std::memory_order_release);
    }
};

Конечно, недостатком является то, что ожидающие потоки не засыпают и не крадут время обработки.

Проверено блокирование

Это, по сути, идея, которую вы продемонстрировали: сначала сделайте быструю проверку, действительно ли требуется блокировка на основе операции атомного свопа и используйте тяжелый std::mutex, только если это неизбежно.

struct FastMux {
    //Status of the fast mutex
    std::atomic<bool> locked;
    //helper mutex and vc on which threads can wait in case of collision
    std::mutex mux;
    std::condition_variable cv;
    //the maximum number of threads that might be waiting on the cv (conservative estimation)
    std::atomic<int> cntr; 

    FastMux():locked(false), cntr(0){}

    void lock() {
        if (locked.exchange(true)) {
            cntr++;
            {
                std::unique_lock<std::mutex> ul(mux);
                cv.wait(ul, [&]{return !locked.exchange(true); });
            }
            cntr--;
        }
    }
    void unlock() {
        locked = false;
        if (cntr > 0){
            std::lock_guard<std::mutex> ul(mux);
            cv.notify_one();
        }
    }
};

Обратите внимание, что std::mutex не заблокирован между lock() и unlock(), но он используется только для обработки переменной условия. Это приводит к большему количеству вызовов блокировки/разблокировки, если на мьютексе имеется большая перегрузка.

Проблема с вашей реализацией заключается в том, что cv.notify_one(); можно потенциально вызывать между if(lockCounter.fetch_add(1, std::memory_order_acquire)>0) и cv.wait(lock);, чтобы ваш поток никогда не мог проснуться.

Я не проводил сравнение производительности с фиксированной версией предлагаемой вами реализации, поэтому вам просто нужно посмотреть, что лучше всего подходит для вас.

Ответ 2

На самом деле не ответ на определение, но в зависимости от конкретной задачи незаблокированная очередь может вообще избавиться от мьютекса. Это поможет дизайну, если у вас есть несколько производителей и один потребитель (или даже несколько потребителей). Ссылки:

• Хотя не напрямую С++/STL, Boost.Lockfree предоставляет такую ​​очередь.
• Другим вариантом является реализация очереди без блокировки в "С++ Concurrency в действии" Энтони Уильямса.
• Быстрая блокировка для С++

Обновить ответы на комментарии:

Размер/переполнение очереди:

• Невозможно избежать переполнения очереди, если i) сделает очередь достаточно большой или ii), заставив поток продюсера ждать с нажатием данных после того, как очередь будет заполнена.
• Другой вариант - использовать несколько потребителей и несколько очередей и реализовать параллельное сокращение, но это зависит от того, как обрабатываются данные.

Потребительский поток:

• В очереди можно использовать std::condition_variable и заставить потребительский поток ждать, пока не появятся данные.
• Другим вариантом будет использование таймера для регулярной проверки (опроса) для очереди, не являющейся пустой, после того как она непустая, поток может непрерывно извлекать данные и возвращаться в режим ожидания.