std::mutex в C++: Советы и примеры использования

int shared_counter = 0;
 
void increment_counter() {
    shared_counter++; // Потенциальная гонка данных при многопоточном доступе
}

std::mutex mtx;
int shared_counter = 0;
 
void safely_increment_counter() {
    mtx.lock();
    shared_counter++; // Защищено от гонок
    mtx.unlock();
}

std::mutex mtx;
int shared_data = 0;
 
void process_data() {
    mtx.lock();
    // Критическая секция
    shared_data++;
    // Выполнение других операций с общими данными
    mtx.unlock();
}

void safe_process_data() {
    std::lock_guard<std::mutex> lock(mtx);
    // Критическая секция
    shared_data++;
    // При выходе из области видимости мьютекс автоматически разблокируется
}

void flexible_process() {
    std::unique_lock<std::mutex> lock(mtx);
    
    // Какая-то работа с защищёнными данными
    shared_data++;
    
    lock.unlock(); // Явная разблокировка
    
    // Код, не требующий защиты мьютексом
    perform_heavy_computation();
    
    lock.lock(); // Повторная блокировка
    
    // Снова доступ к защищённым данным
    shared_data--;
}

// Простейшая реализация спин-мьютекса
class spinlock {
    std::atomic_flag flag = ATOMIC_FLAG_INIT;
public:
    void lock() {
        while (flag.test_and_set(std::memory_order_acquire))
            ; // Активное ожидание (спин)
    }
    
    void unlock() {
        flag.clear(std::memory_order_release);
    }
};

std::recursive_mutex rec_mtx;
 
void recursive_function(int depth) {
    std::lock_guard<std::recursive_mutex> lock(rec_mtx);
    
    if (depth <= 0) return;
    
    // Какая-то работа на данном уровне рекурсии
    std::cout << "На глубине: " << depth << std::endl;
    
    // Рекурсивный вызов, снова блокирующий тот же мьютекс
    recursive_function(depth - 1);
    
    // При выходе из каждого уровня рекурсии 
    // счётчик блокировок уменьшается на 1
}

// Неправильно:
void process_data() {
    mtx.lock();
    if (condition_is_met())
        return; // Выход без разблокировки!
    // ...
    mtx.unlock();
}
 
// Правильно:
void process_data() {
    std::lock_guard<std::mutex> lock(mtx);
    if (condition_is_met())
        return; // lock_guard разблокирует мьютекс автоматически
    // ...
}

// Небезопасно:
if (data_queue.empty()) {
    std::lock_guard<std::mutex> lock(mtx);
    // Обработка пустой очереди
} else {
    std::lock_guard<std::mutex> lock(mtx);
    auto item = data_queue.front();
    data_queue.pop();
    // Обработка item
}
 
// Безопасно:
std::lock_guard<std::mutex> lock(mtx);
if (data_queue.empty()) {
    // Обработка пустой очереди
} else {
    auto item = data_queue.front();
    data_queue.pop();
    // Обработка item
}

std::mutex mtx1, mtx2;
 
// Поток 1
void thread1_func() {
    std::lock_guard<std::mutex> lock1(mtx1);
    std::this_thread::sleep_for(std::chrono::milliseconds(1)); // Увеличивает шанс возникновения взаимоблокировки
    std::lock_guard<std::mutex> lock2(mtx2);
    // ...
}
 
// Поток 2
void thread2_func() {
    std::lock_guard<std::mutex> lock2(mtx2);
    std::this_thread::sleep_for(std::chrono::milliseconds(1));
    std::lock_guard<std::mutex> lock1(mtx1);
    // ...
}

void safe_operation() {
    std::unique_lock<std::mutex> lock1(mtx1, std::defer_lock);
    std::unique_lock<std::mutex> lock2(mtx2, std::defer_lock);
    
    std::lock(lock1, lock2); // Атомарно блокирует оба мьютекса
    
    // Теперь оба мьютекса заблокированы
}

void safe_operation_cpp17() {
    std::scoped_lock locks(mtx1, mtx2); // Блокирует все мьютексы без риска взаимоблокировки
    // ...
}

// Небезопасно:
int get_value() {
    return shared_counter; // Незащищённое чтение!
}
 
void increment_value() {
    std::lock_guard<std::mutex> lock(mtx);
    shared_counter++;
}
 
// Безопасно:
int get_value() {
    std::lock_guard<std::mutex> lock(mtx);
    return shared_counter;
}

// Опасно:
std::vector<int>* data_ptr;
{
    std::lock_guard<std::mutex> lock(mtx);
    data_ptr = &shared_vector;
}
data_ptr->push_back(42); // Незащищённый доступ!
 
// Безопасно:
{
    std::lock_guard<std::mutex> lock(mtx);
    shared_vector.push_back(42);
}

std::shared_mutex shared_mtx;
 
void read_data() {
    std::shared_lock<std::shared_mutex> lock(shared_mtx);
    // Несколько потоков могут одновременно читать данные
}
 
void write_data() {
    std::unique_lock<std::shared_mutex> lock(shared_mtx);
    // Только один поток может писать, блокируя все остальные
}

// Определите порядок блокировок
if (&mutex1 < &mutex2) {
    std::lock_guard<std::mutex> lock1(mutex1);
    std::lock_guard<std::mutex> lock2(mutex2);
    // Работа с защищенными ресурсами
} else {
    std::lock_guard<std::mutex> lock2(mutex2);
    std::lock_guard<std::mutex> lock1(mutex1);
    // Работа с защищенными ресурсами
}

std::mutex m1, m2, m3;
 
void complex_operation() {
    std::unique_lock<std::mutex> lock1(m1, std::defer_lock);
    std::unique_lock<std::mutex> lock2(m2, std::defer_lock);
    std::unique_lock<std::mutex> lock3(m3, std::defer_lock);
    
    std::lock(lock1, lock2, lock3);
    
    // Работа с защищенными ресурсами
}

void modern_complex_operation() {
    std::scoped_lock locks(m1, m2, m3);
    
    // Работа с защищенными ресурсами
    // При выходе из области видимости все мьютексы разблокируются
}

enum class hierarchy_level { high = 0, medium = 1, low = 2 };
 
class hierarchical_mutex {
    std::mutex mtx;
    const hierarchy_level level;
    static thread_local hierarchy_level current_thread_level;
    
public:
    explicit hierarchical_mutex(hierarchy_level lvl) : level(lvl) {}
    
    void lock() {
        if (current_thread_level <= level) {
            throw std::logic_error("Нарушение иерархии мьютексов");
        }
        
        mtx.lock();
        current_thread_level = level;
    }
    
    void unlock() {
        current_thread_level = hierarchy_level::high;
        mtx.unlock();
    }
    
    bool try_lock() {
        if (current_thread_level <= level) {
            return false;
        }
        
        if (!mtx.try_lock()) {
            return false;
        }
        
        current_thread_level = level;
        return true;
    }
};
 
thread_local hierarchy_level hierarchical_mutex::current_thread_level = hierarchy_level::high;

std::mutex mtx;
std::condition_variable cv;
bool data_ready = false;
 
void producer() {
    // Подготовка данных
    
    {
        std::lock_guard<std::mutex> lock(mtx);
        data_ready = true;
    }
    
    cv.notify_one(); // Или cv.notify_all() для оповещения всех ожидающих потоков
}
 
void consumer() {
    std::unique_lock<std::mutex> lock(mtx);
    
    // Ожидание, пока data_ready не станет true
    cv.wait(lock, [](){ return data_ready; });
    
    // Работа с данными
}

std::mutex mtx;
 
void try_process() {
    if (mtx.try_lock()) {
        // Мьютекс успешно захвачен
        // Выполнить критическую секцию
        mtx.unlock();
    } else {
        // Мьютекс занят, выполнить альтернативное действие
    }
}

std::timed_mutex tmtx;
 
void process_with_timeout() {
    // Попытка захватить мьютекс в течение 100 миллисекунд
    if (tmtx.try_lock_for(std::chrono::milliseconds(100))) {
        // Мьютекс успешно захвачен в течение таймаута
        // Выполнить критическую секцию
        tmtx.unlock();
    } else {
        // Не удалось захватить мьютекс в течение указанного времени
    }
    
    // Или захватить до указанного момента времени:
    auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(1);
    if (tmtx.try_lock_until(deadline)) {
        // Мьютекс успешно захвачен до истечения срока
        tmtx.unlock();
    }
}

std::timed_mutex tmtx;
 
void process_with_unique_lock_timeout() {
    std::unique_lock<std::timed_mutex> lock(tmtx, std::defer_lock);
    if (lock.try_lock_for(std::chrono::milliseconds(200))) {
        // Мьютекс захвачен успешно
    } else {
        // Тайм-аут истёк без захвата мьютекса
    }
}

std::mutex mtx;
std::condition_variable cv;
bool data_ready = false;
 
void consumer_with_timeout() {
    std::unique_lock<std::mutex> lock(mtx);
    
    // Ожидание с таймаутом в 1 секунду
    if (cv.wait_for(lock, std::chrono::seconds(1), [](){ return data_ready; })) {
        // Условие выполнено в течение таймаута
    } else {
        // Тайм-аут истёк, условие не выполнено
    }
}

std::mutex m1, m2, m3;
 
void safe_transfer(int& from, int& to) {
    // Создаём объекты управления блокировкой, но не блокируем мьютексы сразу
    std::unique_lock<std::mutex> lock_from(m1, std::defer_lock);
    std::unique_lock<std::mutex> lock_to(m2, std::defer_lock);
    
    // Атомарно блокируем оба мьютекса без риска взаимоблокировки
    std::lock(lock_from, lock_to);
    
    // Теперь оба ресурса защищены
    from -= 100;
    to += 100;
}

std::mutex m1, m2, m3;
 
void modern_transfer(int& from, int& to) {
 // Все мьютексы блокируются одновременно без риска взаимоблокировки
 std::scoped_lock lock(m1, m2, m3);
 
 // Защищённые операции
 from -= 100;
 to += 100;
}

class adaptive_mutex {
private:
 std::atomic<bool> flag{false};
 std::mutex mtx;
 const unsigned int spin_count;
 
public:
 adaptive_mutex(unsigned int spins = 1000) : spin_count(spins) {}
 
 void lock() {
     // Сначала пытаемся захватить с помощью атомарных операций
     for (unsigned int i = 0; i < spin_count; ++i) {
         bool expected = false;
         if (flag.compare_exchange_weak(expected, true, 
             std::memory_order_acquire, std::memory_order_relaxed)) {
             return; // Успешно захватили
         }
         
         // Короткая пауза для снижения нагрузки на шину
         _mm_pause(); // Инструкция для x86, на других архитектурах может отличаться
     }
     
     // Если не удалось захватить за spin_count попыток, используем тяжёлый мьютекс
     mtx.lock();
     bool expected = false;
     while (!flag.compare_exchange_weak(expected, true, 
            std::memory_order_acquire, std::memory_order_relaxed)) {
         expected = false;
     }
     mtx.unlock();
 }
 
 void unlock() {
     flag.store(false, std::memory_order_release);
 }
};

adaptive_mutex amtx;
 
void critical_operation() {
 std::lock_guard<adaptive_mutex> lock(amtx);
 // Критическая секция
}

// До C++17
void transfer_funds(Account& from, Account& to, double amount) {
 std::unique_lock<std::mutex> lock_from(from.mtx, std::defer_lock);
 std::unique_lock<std::mutex> lock_to(to.mtx, std::defer_lock);
 std::lock(lock_from, lock_to);
 
 from.balance -= amount;
 to.balance += amount;
}
 
// С C++17
void transfer_funds_modern(Account& from, Account& to, double amount) {
 std::scoped_lock lock(from.mtx, to.mtx);
 
 from.balance -= amount;
 to.balance += amount;
}

void complex_operation(Resource1& r1, Resource2& r2, Resource3& r3) {
 std::scoped_lock lock(r1.mutex, r2.timed_mutex, r3.recursive_mutex);
 
 // Операции с ресурсами
}

std::shared_mutex smtx;
std::vector<int> shared_data;
 
void reader() {
 std::shared_lock<std::shared_mutex> lock(smtx); // Блокировка для чтения
 
 // Чтение данных без изменения
 for (auto item : shared_data) {
     process(item);
 }
}
 
void writer(int value) {
 std::unique_lock<std::shared_mutex> lock(smtx); // Эксклюзивная блокировка для записи
 
 // Изменение данных
 shared_data.push_back(value);
}

template<typename Key, typename Value>
class threadsafe_cache {
private:
 std::map<Key, Value> cache_map;
 mutable std::shared_mutex cache_mutex;
 
 std::function<Value(const Key&)> value_generator;
 
public:
 explicit threadsafe_cache(std::function<Value(const Key&)> generator)
     : value_generator(generator) {}
 
 Value get(const Key& key) {
     // Сначала пробуем найти значение, используя блокировку для чтения
     {
         std::shared_lock<std::shared_mutex> lock(cache_mutex);
         auto it = cache_map.find(key);
         if (it != cache_map.end()) {
             return it->second;
         }
     }
     
     // Не нашли значение, генерируем его, используя блокировку для записи
     std::unique_lock<std::shared_mutex> lock(cache_mutex);
     
     // Повторная проверка (double-checked locking)
     auto it = cache_map.find(key);
     if (it != cache_map.end()) {
         return it->second;
     }
     
     Value value = value_generator(key);
     cache_map.insert(std::make_pair(key, value));
     return value;
 }
 
 void invalidate(const Key& key) {
     std::unique_lock<std::shared_mutex> lock(cache_mutex);
     cache_map.erase(key);
 }
};

// Крупнозернистая блокировка — один мьютекс на весь список
class coarse_grained_list {
    struct node {
        int data;
        std::unique_ptr<node> next;
    };
    
    std::unique_ptr<node> head;
    std::mutex list_mutex;
 
public:
    void add(int value) {
        std::lock_guard<std::mutex> lock(list_mutex);
        
        // Весь список блокируется на время вставки
        auto new_node = std::make_unique<node>();
        new_node->data = value;
        new_node->next = std::move(head);
        head = std::move(new_node);
    }
    
    bool contains(int value) {
        std::lock_guard<std::mutex> lock(list_mutex);
        
        // Весь список блокируется даже для чтения
        for (auto* current = head.get(); current; current = current->next.get()) {
            if (current->data == value) return true;
        }
        return false;
    }
};
 
// Мелкозернистая блокировка — мьютекс для каждого узла
class fine_grained_list {
    struct node {
        int data;
        std::unique_ptr<node> next;
        std::mutex node_mutex;
    };
    
    std::unique_ptr<node> head;
    std::mutex head_mutex;
 
public:
    void add(int value) {
        auto new_node = std::make_unique<node>();
        new_node->data = value;
        
        std::lock_guard<std::mutex> lock(head_mutex);
        new_node->next = std::move(head);
        head = std::move(new_node);
    }
    
    bool contains(int value) {
        std::unique_lock<std::mutex> head_lock(head_mutex, std::defer_lock);
        
        node* current = nullptr;
        node* next = head.get();
        
        while (next) {
            if (head_lock.owns_lock()) {
                current = next;
                next = next->next.get();
                
                // Переходим к блокировке следующего узла
                std::unique_lock<std::mutex> next_lock(next ? next->node_mutex : head_mutex);
                head_lock.unlock();
                head_lock = std::move(next_lock);
            } else {
                head_lock = std::unique_lock<std::mutex>(next->node_mutex);
                current = next;
                next = next->next.get();
            }
            
            if (current->data == value) return true;
        }
        
        return false;
    }
};

std::mutex data_mutex;
std::vector<int> shared_data;
 
void process_data() {
    std::vector<int> local_copy;
    {
        std::lock_guard<std::mutex> lock(data_mutex);
        local_copy = shared_data; // Создаём копию под защитой мьютекса
    }
    
    // Обрабатываем копию без блокировки
    for (auto& item : local_copy) {
        heavy_processing(item);
    }
}

struct User {
    std::string name;
    int age;
    // ... другие поля
};
 
std::mutex users_mutex;
std::vector<User> users;
 
void add_processed_user(const std::string& name, int age) {
    // Фаза 1: Подготовка (без блокировки)
    User new_user;
    new_user.name = name;
    new_user.age = age;
    // ... выполнение других тяжёлых операций
    
    // Фаза 2: Модификация (с блокировкой)
    {
        std::lock_guard<std::mutex> lock(users_mutex);
        users.push_back(new_user);
    }
}

std::atomic<unsigned> version{0};
std::mutex data_mutex;
std::vector<int> shared_data;
 
bool try_optimistic_update(int index, int new_value) {
    unsigned current_version = version.load(std::memory_order_acquire);
    
    // Читаем данные без блокировки (оптимистично)
    int old_value;
    {
        std::lock_guard<std::mutex> lock(data_mutex);
        if (index >= shared_data.size()) return false;
        old_value = shared_data[index];
    }
    
    // Выполняем длительную проверку без блокировки
    if (!validate_transition(old_value, new_value)) {
        return false;
    }
    
    // Пытаемся обновить данные
    {
        std::lock_guard<std::mutex> lock(data_mutex);
        
        // Проверяем, не изменились ли данные
        if (version.load(std::memory_order_acquire) != current_version || 
            shared_data[index] != old_value) {
            return false; // Данные изменились, отменяем операцию
        }
        
        shared_data[index] = new_value;
        version.fetch_add(1, std::memory_order_release);
        return true;
    }
}

class instrumented_mutex {
    std::mutex mtx;
    std::atomic<unsigned long> contentions{0};
    std::atomic<unsigned long> total_wait_ns{0};
 
public:
    void lock() {
        auto start = std::chrono::high_resolution_clock::now();
        
        if (!mtx.try_lock()) {
            contentions.fetch_add(1, std::memory_order_relaxed);
            mtx.lock();
            auto end = std::chrono::high_resolution_clock::now();
            auto wait_time = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start);
            total_wait_ns.fetch_add(wait_time.count(), std::memory_order_relaxed);
        }
    }
    
    void unlock() {
        mtx.unlock();
    }
    
    bool try_lock() {
        return mtx.try_lock();
    }
    
    unsigned long get_contentions() const {
        return contentions.load(std::memory_order_relaxed);
    }
    
    unsigned long get_total_wait_ns() const {
        return total_wait_ns.load(std::memory_order_relaxed);
    }
    
    double get_average_wait_ns() const {
        auto c = contentions.load(std::memory_order_relaxed);
        return c > 0 ? total_wait_ns.load(std::memory_order_relaxed) / static_cast<double>(c) : 0;
    }
};

// С использованием мьютекса
std::mutex counter_mutex;
int shared_counter = 0;
 
void increment_with_mutex() {
    std::lock_guard<std::mutex> lock(counter_mutex);
    shared_counter++;
}
 
// Без блокировок, с атомарными операциями
std::atomic<int> atomic_counter{0};
 
void increment_lockless() {
    atomic_counter.fetch_add(1, std::memory_order_relaxed);
}

template<typename T>
bool cas_update(std::atomic<T>& target, T expected, T desired) {
    return target.compare_exchange_strong(expected, desired);
}
 
bool push_stack_item(std::atomic<node*>& head, int value) {
    node* new_node = new node{value, nullptr};
    node* old_head = head.load();
    
    do {
        new_node->next = old_head;
    } while (!head.compare_exchange_weak(old_head, new_node));
    
    return true;
}

struct versioned_ptr {
    void* ptr;
    uint64_t version;
};
 
std::atomic<versioned_ptr> atomic_versioned{nullptr, 0};
 
bool update_with_version(int new_value) {
    versioned_ptr current = atomic_versioned.load();
    versioned_ptr new_value_ptr = {
        new int(new_value),
        current.version + 1
    };
    
    return atomic_versioned.compare_exchange_strong(current, new_value_ptr);
}

// Атомарное чтение — обычно самая быстрая операция
int value = atomic_var.load(std::memory_order_relaxed);
 
// Атомарная запись — тоже относительно быстрая
atomic_var.store(new_value, std::memory_order_relaxed);
 
// Атомарный обмен — может быть дороже
int old_value = atomic_var.exchange(new_value);
 
// Атомарное сравнение-и-обмен — часто самая дорогая операция
expected = old_value;
if (atomic_var.compare_exchange_strong(expected, new_value)) {
    // Успешное обновление
}

// Наиболее строгий порядок, но с наибольшими накладными расходами
atomic_counter.fetch_add(1, std::memory_order_seq_cst);
 
// Минимальные гарантии, но максимальная производительность
atomic_counter.fetch_add(1, std::memory_order_relaxed);

// Потенциальный false sharing
struct data {
    std::atomic<int> counter1; // Используется первым потоком
    std::atomic<int> counter2; // Используется вторым потоком
};
 
// Избегаем false sharing с помощью выравнивания
struct aligned_data {
    alignas(64) std::atomic<int> counter1; // 64 байта — типичный размер линии кэша
    alignas(64) std::atomic<int> counter2;
};

// Мьютекс, за которым часто "охотятся" все потоки
std::mutex hot_mutex; // Постоянно перемещается между кэшами
 
// Лучше: мьютексы, "принадлежащие" каждому объекту
class per_object_locked {
    std::mutex object_mutex;
    int data;
    // ...
};

// Плохо: каждый поток работает с разными полями, но они в одной структуре
struct mixed_data {
    int thread1_counter;
    int thread2_counter;
};
 
// Лучше: разделение на структуры по принадлежности к потокам
struct thread1_data {
    int counter;
};
struct thread2_data {
    int counter;
};

// Вместо одного глобального мьютекса
class finer_locks {
    struct bucket {
        std::mutex mtx;
        std::unordered_map<int, std::string> items;
    };
    
    std::array<bucket, 64> buckets;
    
    bucket& get_bucket(int key) {
        return buckets[hash(key) % buckets.size()];
    }
    
public:
    void insert(int key, const std::string& value) {
        auto& b = get_bucket(key);
        std::lock_guard<std::mutex> lock(b.mtx);
        b.items[key] = value;
    }
};

template<typename T>
class rcu_protected {
    std::mutex write_mutex;
    std::atomic<std::shared_ptr<const T>> data;
    
public:
    rcu_protected(T initial) : data(std::make_shared<T>(std::move(initial))) {}
    
    std::shared_ptr<const T> read() const {
        return data.load();
    }
    
    template<typename Func>
    void update(Func&& updater) {
        std::lock_guard<std::mutex> lock(write_mutex);
        std::shared_ptr<const T> old_data = data.load();
        std::shared_ptr<T> new_data = std::make_shared<T>(*old_data);
        updater(*new_data);
        data.store(new_data);
    }
};

class thread_safe_logger {
private:
    std::mutex log_mutex;
    std::ofstream log_file;
 
public:
    thread_safe_logger(const std::string& filename) {
        log_file.open(filename, std::ios::app);
    }
 
    ~thread_safe_logger() {
        if (log_file.is_open()) {
            log_file.close();
        }
    }
 
    void log(const std::string& message) {
        std::lock_guard<std::mutex> lock(log_mutex);
        log_file << std::time(nullptr) << ": " << message << std::endl;
    }
};

template<typename T>
class threadsafe_stack {
private:
    std::stack<T> data;
    mutable std::mutex m;
 
public:
    threadsafe_stack() = default;
 
    threadsafe_stack(const threadsafe_stack& other) {
        std::lock_guard<std::mutex> lock(other.m);
        data = other.data;
    }
 
    threadsafe_stack& operator=(const threadsafe_stack&) = delete;
 
    void push(T new_value) {
        std::lock_guard<std::mutex> lock(m);
        data.push(std::move(new_value));
    }
 
    std::shared_ptr<T> pop() {
        std::lock_guard<std::mutex> lock(m);
        if (data.empty()) return nullptr;
        
        std::shared_ptr<T> res(std::make_shared<T>(std::move(data.top())));
        data.pop();
        return res;
    }
 
    bool empty() const {
        std::lock_guard<std::mutex> lock(m);
        return data.empty();
    }
};

class singleton {
private:
    static std::mutex initialization_mutex;
    static std::atomic<singleton*> instance;
    
    singleton() = default;
    singleton(const singleton&) = delete;
    singleton& operator=(const singleton&) = delete;
 
public:
    static singleton* get_instance() {
        singleton* p = instance.load(std::memory_order_acquire);
        if (p == nullptr) {
            std::lock_guard<std::mutex> lock(initialization_mutex);
            p = instance.load(std::memory_order_relaxed);
            if (p == nullptr) {
                p = new singleton();
                instance.store(p, std::memory_order_release);
            }
        }
        return p;
    }
};
 
std::mutex singleton::initialization_mutex;
std::atomic<singleton*> singleton::instance{nullptr};

class better_singleton {
private:
    static std::mutex initialization_mutex;
    static std::atomic<std::shared_ptr<better_singleton>> instance;
    
    better_singleton() = default;
 
public:
    static std::shared_ptr<better_singleton> get_instance() {
        auto p = instance.load(std::memory_order_acquire);
        if (!p) {
            std::lock_guard<std::mutex> lock(initialization_mutex);
            p = instance.load(std::memory_order_relaxed);
            if (!p) {
                p = std::shared_ptr<better_singleton>(new better_singleton());
                instance.store(p, std::memory_order_release);
            }
        }
        return p;
    }
};

class meyers_singleton {
private:
    meyers_singleton() = default;
    
public:
    static meyers_singleton& get_instance() {
        static meyers_singleton instance;
        return instance;
    }
};

template<typename T>
class thread_safe_cache {
private:
    mutable std::shared_mutex cache_mutex;
    std::unordered_map<std::string, T> cache_map;
 
public:
    // Операция чтения (допускает одновременный доступ)
    std::optional<T> get(const std::string& key) const {
        std::shared_lock lock(cache_mutex);
        auto it = cache_map.find(key);
        if (it != cache_map.end()) {
            return it->second;
        }
        return std::nullopt;
    }
    
    // Операция записи (эксклюзивный доступ)
    void set(const std::string& key, T value) {
        std::unique_lock lock(cache_mutex);
        cache_map[key] = std::move(value);
    }
    
    // Удаление элементов (тоже требует эксклюзивного доступа)
    bool remove(const std::string& key) {
        std::unique_lock lock(cache_mutex);
        return cache_map.erase(key) > 0;
    }
};

template<typename T>
class object_pool {
private:
    std::mutex pool_mutex;
    std::vector<std::unique_ptr<T>> resources;
    
public:
    // Получить объект из пула или создать новый
    std::unique_ptr<T> acquire() {
        std::lock_guard<std::mutex> lock(pool_mutex);
        if (resources.empty()) {
            return std::make_unique<T>();
        } else {
            std::unique_ptr<T> resource = std::move(resources.back());
            resources.pop_back();
            return resource;
        }
    }
    
    // Вернуть объект в пул для дальнейшего использования
    void release(std::unique_ptr<T> resource) {
        if (!resource) return;
        
        std::lock_guard<std::mutex> lock(pool_mutex);
        resources.push_back(std::move(resource));
    }
    
    // Размер пула
    size_t size() const {
        std::lock_guard<std::mutex> lock(pool_mutex);
        return resources.size();
    }
};