weak_ptr怎么提升为shared_ptr 线程安全地访问托管对象

#include <iostream>
#include <memory>
#include <thread>
#include <mutex>

class MyObject {
public:
    std::weak_ptr<MyObject> self;

    ~MyObject() {
        std::cout << "MyObject destroyed" << std::endl;
    }
};

int main() {
    std::shared_ptr<MyObject> obj = std::make_shared<MyObject>();
    obj->self = obj; // 循环引用

    // obj离开作用域，但由于循环引用，对象不会被销毁
    return 0;
}

#include <iostream>
#include <memory>
#include <atomic>

template <typename T>
std::shared_ptr<T> weak_ptr_to_shared(const std::weak_ptr<T>& weak) {
    std::shared_ptr<T> shared = weak.lock();
    if (shared) {
        return shared;
    } else {
        return nullptr;
    }
}

int main() {
    std::shared_ptr<int> shared = std::make_shared<int>(42);
    std::weak_ptr<int> weak = shared;

    std::shared_ptr<int> new_shared = weak_ptr_to_shared(weak);

    if (new_shared) {
        std::cout << "Value: " << *new_shared << std::endl;
    } else {
        std::cout << "Object is no longer valid." << std::endl;
    }

    shared.reset(); // 释放shared_ptr

    new_shared = weak_ptr_to_shared(weak);

    if (new_shared) {
        std::cout << "Value: " << *new_shared << std::endl;
    } else {
        std::cout << "Object is no longer valid." << std::endl; // 会执行到这里
    }

    return 0;
}

#include <iostream>
#include <memory>
#include <mutex>
#include <thread>

class ThreadSafeObject {
public:
    ThreadSafeObject(int value) : value_(value) {}

    void increment() {
        std::lock_guard<std::mutex> lock(mutex_);
        value_++;
        std::cout << "Value incremented to: " << value_ << " by thread " << std::this_thread::get_id() << std::endl;
    }

    int getValue() {
        std::lock_guard<std::mutex> lock(mutex_);
        return value_;
    }

private:
    int value_;
    std::mutex mutex_;
};

int main() {
    std::shared_ptr<ThreadSafeObject> obj = std::make_shared<ThreadSafeObject>(0);

    std::thread t1([obj]() {
        for (int i = 0; i < 1000; ++i) {
            obj->increment();
        }
    });

    std::thread t2([obj]() {
        for (int i = 0; i < 1000; ++i) {
            obj->increment();
        }
    });

    t1.join();
    t2.join();

    std::cout << "Final value: " << obj->getValue() << std::endl;

    return 0;
}

#include <iostream>
#include <memory>
#include <shared_mutex>
#include <thread>
#include <vector>

class ThreadSafeCounter {
public:
    ThreadSafeCounter() : value_(0) {}

    int get() const {
        std::shared_lock<std::shared_mutex> lock(mutex_); // 共享锁，允许多个读者
        return value_;
    }

    void increment() {
        std::unique_lock<std::shared_mutex> lock(mutex_); // 独占锁，只允许一个写者
        value_++;
    }

private:
    mutable std::shared_mutex mutex_; // 注意mutable关键字
    int value_;
};

int main() {
    std::shared_ptr<ThreadSafeCounter> counter = std::make_shared<ThreadSafeCounter>();

    std::vector<std::thread> threads;
    for (int i = 0; i < 5; ++i) {
        threads.emplace_back([counter]() {
            for (int j = 0; j < 1000; ++j) {
                counter->increment();
            }
        });
    }

    for (int i = 0; i < 3; ++i) {
        threads.emplace_back([counter]() {
            for (int j = 0; j < 1000; ++j) {
                std::cout << "Counter value: " << counter->get() << std::endl;
            }
        });
    }

    for (auto& thread : threads) {
        thread.join();
    }

    std::cout << "Final counter value: " << counter->get() << std::endl;

    return 0;
}