C++手撕共享指针、多线程交替、LRU缓存

 1. 共享指针

1. #include <atomic>
2. #include <iostream>
4. template <typename T> class sharedptr {
5. private:
6.   T *ptr;
7.   std::atomic<size_t> *count;
9. public:
10.   sharedptr(T *p) : ptr(p), count(new std::atomic<size_t>(1)) {}
11.   sharedptr(const sharedptr &other) : ptr(other.ptr), count(other.count) {
12.     (*count)++;
13.   }
14.   sharedptr(sharedptr &&other) : ptr(other.ptr), count(other.count) {
15.     other.ptr = nullptr;
16.     other.count = nullptr;
17.   }
18.   // 拷贝赋值运算符
19.   // 何时调用？当用一个 ​已存在的对象（左值）​
20.   // 赋值给另一个已存在的对象时： Myclass a,b;
21.   sharedptr &operator=(const sharedptr &other) {
22.     if (this != &other) {
23.       release();
24.       ptr = other.ptr;
25.       count = other.count;
26.       (*count)++;
27.     }
28.     return *this;
29.   }
30.   // 移动赋值运算符
31.   sharedptr &operator=(sharedptr &&other) {
32.     if (this != &other) {
33.       ptr = other.ptr;
34.       count = other.count;
35.       other.ptr = nullptr;
36.       other.count = nullptr;
37.     }
38.     return *this;
39.   }
40.   void release() {
41.     if (count != nullptr && (--(*count)) == 0) {
42.       delete ptr;
43.       delete count;
44.     }
45.   }
46.   ~sharedptr() { release(); }
47.   T *operator->() { return ptr; }
48.   T &operator*() { return *ptr; }
49. };
50. int main() {}

复制代码

1. 快速影象

• ​双成员布局：
  
  
  
  • T* ptr管理资源
    
  • atomic<size_t>* count保证线程安全
    
  
  
• ​五大特殊函数：
  
  1. // 1. 构造
  2. explicit Shared_Ptr(T* p = nullptr)
  4. // 2. 拷贝构造
  5. Shared_Ptr(const Shared_Ptr&)
  7. // 3. 移动构造（noexcept优化）
  8. Shared_Ptr(Shared_Ptr&&) noexcept
  10. // 4. 拷贝赋值（自检+释放旧值：等号左）
  11. operator=(const Shared_Ptr&)
  13. // 5. 移动赋值（自检+释放旧值：等号右）
  14. operator=(Shared_Ptr&&) noexcept

  复制代码
• 发起手写时按以下顺序实现
  
  
  
  • 成员变量
    
  • 构造函数
    
  • 拷贝构造/赋值
    
  • 移动构造/赋值
    
  • 析构函数
    
  • 操作符重载
    
  • 辅助方法
    
  
  

2. 多线程交替打印

代码：

1. #include <condition_variable>
2. #include <iostream>
3. #include <mutex>
4. #include <thread>
6. int m;
7. std::mutex mtx;
8. std::condition_variable cv;
9. void print(int target) {
10.   for (int i = 0; i < 10; i++) {
11.     // 这行代码相当重要
12.     std::unique_lock<std::mutex> lock(mtx);
13.     // 条件谓词不接受参数
14.     cv.wait(lock, [&]() { return m == target; });
15.     std::cout << m << std::endl;
16.     m = (m + 1) % 3;
17.     cv.notify_all();
18.   }
19. }
20. int main() {
21.   m = 0;
22.   std::thread t1(print, 0);
23.   std::thread t2(print, 1);
24.   std::thread t3(print, 2);
26.   t1.join();
27.   t2.join();
28.   t3.join();
29. }

复制代码

1. std::unique_lock<std::mutex>对象lock和std::mutex对象mtx是什么关系？

std::unique_lock<std::mutex> 是一个管理互斥量（std::mutex）的 RAII（资源获取即初始化）包装器。两者的关系如下：

• 绑定关系：当你创建一个 std::unique_lock<std::mutex> 对象时，通常会将一个 std::mutex 对象（好比 mtx）传递给它。此时，unique_lock 会主动尝试锁定这个互斥量。
  
• 主动管理：unique_lock 在其生命周期内拥有并管理这个 mtx 的锁定状态。当 unique_lock 对象烧毁时（例如超出作用域），它会主动解锁 mtx，制止手动解锁带来的错误风险。
  
• 灵活性：与 std::lock_guard 相比，unique_lock 提供了更多的灵活性，好比能够延迟锁定、手动解锁或重新锁定，以及支持条件变量等候时的锁管理。
  
• 个人明白：所谓mutex(mutual exclusion)，本身仅是声明了一个互斥量，此时并不包含锁的意义
  

2. 简述一下cv.wait和notify做了什么？

• cv.wait
  
  
  
  • 等候与解锁：调用 cv.wait(lock, predicate) 时，线程会进入等候状态，同时主动释放传入的 std::unique_lock 持有的互斥量。这使得其他线程可以获得该互斥量，从而修改共享数据。
    
  • 阻塞与恢复：当等候的条件（通常由传入的 lambda 表达式 predicate 检查）不满意时，线程会不停阻塞。待其他线程调用 notify 方法后，等候线程会被叫醒并重新尝试获取锁，随后检查条件，直到条件满意为止。
    
  
  
• notify
  
  
  
  • 叫醒等候线程：cv.notify_one() 会叫醒一个正等候此条件变量的线程，而 cv.notify_all() 则会叫醒所有等候的线程。
    
  • 同步机制：当某个线程修改了共享数据并满意了等候线程所盼望的条件后，它会调用 notify 方法通知等候线程，促使它们从阻塞状态中恢复，继续执行。
    
  
  

3. LRU缓存

1. class LRUCache {
2. private:
3.     int capacity;
4.     list<pair<int,int>> mylist;
5.     unordered_map<int,list<pair<int,int>>::iterator> umap;
6. public:
8.     LRUCache(int capacity):capacity(capacity) {
10.     }
11.    
12.     int get(int key) {
13.         if(umap.find(key)==umap.end())  {return -1;}
14.         int value=umap[key]->second;
15.         mylist.erase(umap[key]);
16.         mylist.push_front({key,value});
17.         umap[key]=mylist.begin();
18.         return value;
19.     }
20.    
21.     void put(int key, int value) {
22.         if(umap.find(key)!=umap.end()){
23.             mylist.erase(umap[key]);
24.             mylist.push_front({key,value});
25.             umap[key]=mylist.begin();
26.         }   else{
27.                 if(umap.size()==capacity){
28.                     //  不能直接删除end()
29.                     // umap.erase(mylist.end());
30.                     int old_key=mylist.back().first;
31.                     umap.erase(old_key);
32.                     mylist.pop_back();
33.                 }
34.                 mylist.push_front({key,value});
35.                 umap[key]=mylist.begin();
36.         }
37.     }
38. };  

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

继续阅读请点击广告