湛江快速网站建设在哪里做百度网址链接

湛江快速网站建设在哪里做,百度网址链接,单位建网站怎么做,佛山模板建站定制网站共享互斥锁#xff08;SharedMutex#xff09;详解 什么是读写锁#xff1f; 读写锁是一种特殊的锁#xff0c;允许多个读者同时读取#xff0c;但写者必须独占。 普通互斥锁#xff1a; ┌─────────────────────────────────┐ │ 同一…共享互斥锁SharedMutex详解什么是读写锁读写锁是一种特殊的锁允许多个读者同时读取但写者必须独占。普通互斥锁 ┌─────────────────────────────────┐ │ 同一时间只能有一个线程读或写 │ └─────────────────────────────────┘ 读写锁 ┌─────────────────────────────────┐ │ 读者1 读者2 读者3 ← 可以同时 │ │ │ │ 写者1 ← 必须独占没有其他读/写│ └─────────────────────────────────┘为什么需要读写锁场景配置文件 - 读取配置非常频繁每秒1000次 - 修改配置很少每天几次 用普通mutex所有操作串行性能差 用读写锁读操作并发性能好状态图┌─────────────────────────────────────────────┐ │ 空闲状态 │ │ readers_0, writer_false │ └──────────────┬──────────────┬───────────────┘ │ │ lock_shared() lock() │ │ ▼ ▼ ┌──────────────────┐ ┌──────────────────┐ │ 读取状态 │ │ 写入状态 │ │ readers_0 │ │ writer_true │ │ writer_false │ │ readers_0 │ │ │ │ │ │ 允许更多读者加入 │ │ 其他所有人等待 │ └──────────────────┘ └──────────────────┘带注释的代码#includecondition_variable#includemutexclassSharedMutex{private:std::mutex mtx_;// Internal mutex to protect statestd::condition_variable cv_;// For threads to wait and wake upintreaders_0;// Count of active readersboolwriter_false;// Is there an active writer?public:// // Acquire shared (read) lock// Multiple threads can hold this simultaneously// voidlock_shared(){std::unique_lockstd::mutexlock(mtx_);// Wait until no writer is active// Readers can coexist with other readers// But must wait if a writer is workingcv_.wait(lock,[this](){return!writer_;});// Now safe to read, increment reader countreaders_;// Note: lock releases here, other readers can enter}// // Release shared (read) lock// voidunlock_shared(){std::unique_lockstd::mutexlock(mtx_);// One less reader--readers_;// If Im the last reader, wake up waiting writersif(readers_0){cv_.notify_all();}}// // Acquire exclusive (write) lock// Only one thread can hold this// No readers allowed during write// voidlock(){std::unique_lockstd::mutexlock(mtx_);// Wait until:// 1. No other writer is active// 2. No readers are readingcv_.wait(lock,[this](){return!writer_readers_0;});// Now Im the exclusive writerwriter_true;}// // Release exclusive (write) lock// voidunlock(){std::unique_lockstd::mutexlock(mtx_);// Done writingwriter_false;// Wake up everyone (readers and writers)// They will compete for the lockcv_.notify_all();}};// // RAII wrapper for shared lock// Automatically locks on construction// Automatically unlocks on destruction// templatetypenameMutexclassSharedLock{private:Mutexmtx_;public:// Constructor: acquire shared lockexplicitSharedLock(Mutexmtx):mtx_(mtx){mtx_.lock_shared();}// Destructor: release shared lock// Called automatically when object goes out of scope~SharedLock(){mtx_.unlock_shared();}// Non-copyable (prevent double unlock)SharedLock(constSharedLock)delete;SharedLockoperator(constSharedLock)delete;};// // RAII wrapper for exclusive lock// templatetypenameMutexclassUniqueLock{private:Mutexmtx_;public:// Constructor: acquire exclusive lockexplicitUniqueLock(Mutexmtx):mtx_(mtx){mtx_.lock();}// Destructor: release exclusive lock~UniqueLock(){mtx_.unlock();}// Non-copyableUniqueLock(constUniqueLock)delete;UniqueLockoperator(constUniqueLock)delete;};使用示例#includeiostream#includethread#includevectorSharedMutex rw_mutex;intshared_data0;// 读者线程voidreader(intid){SharedLockSharedMutexlock(rw_mutex);// 自动获取读锁std::coutReader id reads: shared_datastd::endl;std::this_thread::sleep_for(std::chrono::milliseconds(100));// 自动释放读锁析构时}// 写者线程voidwriter(intid){UniqueLockSharedMutexlock(rw_mutex);// 自动获取写锁shared_data;std::coutWriter id writes: shared_datastd::endl;std::this_thread::sleep_for(std::chrono::milliseconds(100));// 自动释放写锁析构时}intmain(){std::vectorstd::threadthreads;// 启动多个读者和写者for(inti0;i3;i){threads.emplace_back(reader,i);}threads.emplace_back(writer,0);for(inti3;i6;i){threads.emplace_back(reader,i);}threads.emplace_back(writer,1);for(autot:threads){t.join();}return0;}执行时序图时间 ──────────────────────────────────────────► Reader1: ████████ Reader2: ████████ 多个读者同时读 Reader3: ████████ Writer0: ████████ 写者独占 Reader4: ████████ Reader5: ████████ 又可以多个读者同时 Reader6: ████████ Writer1: ████████ 写者独占案例#includechrono#includeiostream#includethread#includevector#includemy_shared.hclassDataStore{private:intdata_0;mutableSharedMutex mtx_;public:intread()const{SharedLockSharedMutexlock(mtx_);std::cout[Thread std::this_thread::get_id()] Reading: data_\n;std::this_thread::sleep_for(std::chrono::milliseconds(100));returndata_;}voidwrite(intvalue){UniqueLockSharedMutexlock(mtx_);std::cout[Thread std::this_thread::get_id()] Writing: value\n;data_value;std::this_thread::sleep_for(std::chrono::milliseconds(100));}};intmain(){DataStore store;std::vectorstd::threadthreads;// 3 readersfor(inti0;i3;i){threads.emplace_back([store](){for(intj0;j3;j){store.read();}});}// 1 writerthreads.emplace_back([store](){for(intj1;j3;j){store.write(j*100);}});for(autot:threads){t.join();}return0;}总结概念说明readers_当前正在读的线程数writer_是否有线程正在写lock_shared()获取读锁等待没有写者lock()获取写锁等待没有读者和写者RAII构造时加锁析构时解锁防止忘记解锁写者优先的读写锁Writer Priority SharedMutex详解为什么需要写者优先普通读写锁的问题 时间 ─────────────────────────────────────────────► Reader1: ████████ Reader2: ████████ Reader3: ████████ Reader4: ████████ Reader5: ████████ ... Writer: 等待...等待...等待...等待... 饿死了 读者不断进来写者永远拿不到锁 写者饥饿写者优先 时间 ─────────────────────────────────────────────► Reader1: ████████ Reader2: ████████ ↓ 写者来了新读者必须等待 Writer: ████████ ↓ 写者完成读者才能继续 Reader3: ████████ Reader4: ████████状态图┌─────────────────────────────────────────────────────┐ │ 空闲状态 │ │ readers_0, writer_false, waiting_writers_0 │ └───────────────┬─────────────────────┬───────────────┘ │ │ lock_shared() lock() │ │ ▼ ▼ ┌────────────────────┐ ┌────────────────────────────┐ │ 读取状态 │ │ 写入状态 │ │ readers_ 0 │ │ writer_ true │ │ writer_ false │ │ readers_ 0 │ │ │ │ │ │ 如果 waiting_writers_0 │ │ │ │ 新读者不能进入 │ │ │ └────────────────────┘ └────────────────────────────┘关键区别普通读写锁 ┌─────────────────────────────────────────┐ │ 读者等待条件: !writer_ │ │ → 只要没人写读者就进来 │ └─────────────────────────────────────────┘ 写者优先读写锁 ┌─────────────────────────────────────────┐ │ 读者等待条件: !writer_ waiting_writers_0 │ │ → 没人写 AND 没人等着写读者才能进来 │ └─────────────────────────────────────────┘带注释的代码#includecondition_variable#includemutexclassSharedMutexWriterPriority{private:std::mutex mtx_;std::condition_variable reader_cv_;// Readers wait on thisstd::condition_variable writer_cv_;// Writers wait on thisintreaders_0;// Count of active readersintwaiting_writers_0;// Count of writers waiting in queueboolwriter_false;// Is there an active writer?public:// // Acquire shared (read) lock// Writers have priority over new readers!// voidlock_shared(){std::unique_lockstd::mutexlock(mtx_);// Wait if:// 1. A writer is currently writing, OR// 2. Writers are waiting (give them priority!)//// This is the KEY difference from basic SharedMutex// New readers must wait for all waiting writersreader_cv_.wait(lock,[this](){return!writer_waiting_writers_0;});// Safe to read nowreaders_;}// // Release shared (read) lock// voidunlock_shared(){std::unique_lockstd::mutexlock(mtx_);--readers_;// If Im the last reader, wake up ONE waiting writer// (not all, just one - more efficient)if(readers_0){writer_cv_.notify_one();}}// // Acquire exclusive (write) lock// voidlock(){std::unique_lockstd::mutexlock(mtx_);// Register myself as waiting writer// This blocks new readers from entering!waiting_writers_;// Wait until no writer AND no readerswriter_cv_.wait(lock,[this](){return!writer_readers_0;});// Got the lock, no longer waiting--waiting_writers_;writer_true;}// // Release exclusive (write) lock// voidunlock(){std::unique_lockstd::mutexlock(mtx_);writer_false;// Priority: wake writers firstif(waiting_writers_0){// More writers waiting, let them go firstwriter_cv_.notify_one();}else{// No writers waiting, let all readers goreader_cv_.notify_all();}}};两种读写锁对比普通读写锁 写者优先读写锁 ────────── ────────────── condition_variable 1个(共用) 2个(分开) 读者等待条件 !writer_ !writer_ waiting_writers_0 写者等待条件 !writer_ !writer_ readers_0 readers_0 unlock时 notify_all 先notify写者 没写者再notify读者 优点 简单公平 写者不会饿死 缺点 写者可能饿死 读者可能饿死执行时序对比场景: R1, R2进入 → W1请求 → R3, R4请求 → W1完成 → W2请求 普通读写锁: ──────────────────────────────────────────────────────────► R1: ████████████████████ R2: ████████████████████ R3: ████████████████████████ ← R3进入(不管W1在等) R4: ████████████████████ ← R4进入(不管W1在等) W1: ████████ ← 等很久 W2: ████████ 写者优先: ──────────────────────────────────────────────────────────► R1: ████████████ R2: ████████████ ↓ W1开始等待,阻止新读者 W1: ████████ W2: ████████ ← W2优先 R3: ████████ ← 写者都完成后 R4: ████████使用示例#includeiostream#includethread#includevector#includechronoSharedMutexWriterPriority rw_mutex;intshared_data0;voidreader(intid){std::coutReader id waiting...std::endl;rw_mutex.lock_shared();std::coutReader id reading: shared_datastd::endl;std::this_thread::sleep_for(std::chrono::milliseconds(100));rw_mutex.unlock_shared();std::coutReader id donestd::endl;}voidwriter(intid){std::coutWriter id waiting...std::endl;rw_mutex.lock();shared_data;std::coutWriter id writing: shared_datastd::endl;std::this_thread::sleep_for(std::chrono::milliseconds(100));rw_mutex.unlock();std::coutWriter id donestd::endl;}intmain(){std::vectorstd::threadthreads;// 先启动读者threads.emplace_back(reader,1);threads.emplace_back(reader,2);std::this_thread::sleep_for(std::chrono::milliseconds(10));// 写者请求threads.emplace_back(writer,1);std::this_thread::sleep_for(std::chrono::milliseconds(10));// 更多读者请求 (会被阻塞因为写者在等待)threads.emplace_back(reader,3);threads.emplace_back(reader,4);for(autot:threads){t.join();}return0;}总结概念说明waiting_writers_等待中的写者数量用于阻止新读者reader_cv_读者专用的条件变量writer_cv_写者专用的条件变量核心思想写者开始等待时新读者就不能进入适用场景写操作重要、不能延迟的场景