主页 / coding / 问题 / 79135575
Accepted
Amir Zhaybev
Asked: 2024-10-29 09:54:19 +0800 CST

优化多线程 C++ 应用程序中的内存管理

  • 772

我尝试了几种逻辑来处理我的这个问题。

  1. 使用线程本地存储 (TLS)
#include <iostream>
#include <thread>

void thread_function() {
    thread_local int local_var = 0;
    local_var++;
    std::cout << "Local variable value: " << local_var << std::endl;
}

int main() {
    std::thread t1(thread_function);
    std::thread t2(thread_function);
    t1.join();
    t2.join();
    return 0;
}
  1. 应用智能指针
#include <iostream>
#include <memory>

void shared_pointer_example() {
    std::shared_ptr<int> sptr(new int(10));
    std::shared_ptr<int> sptr2 = sptr; // reference count increased
    std::cout << "Shared Pointer value: " << *sptr << std::endl;
}

void unique_pointer_example() {
    std::unique_ptr<int> uptr(new int(20));
    std::cout << "Unique Pointer value: " << *uptr << std::endl;
    // std::unique_ptr<int> uptr2 = uptr; // Error: unique_ptr cannot be copied
}

int main() {
    shared_pointer_example();
    unique_pointer_example();
    return 0;
}
  1. 实现无锁数据结构
#include <iostream>
#include <atomic>
#include <vector>
#include <thread>

std::atomic<int> atomic_counter(0);

void increment() {
    for (int i = 0; i < 1000; ++i) {
        atomic_counter++;
    }
}

int main() {
    std::vector<std::thread> threads;
    for (int i = 0; i < 10; ++i) {
        threads.emplace_back(increment);
    }
    for (auto& t : threads) {
        t.join();
    }
    std::cout << "Atomic Counter: " << atomic_counter.load() << std::endl;
    return 0;
}

但实际上，没有一个是直观的，或者足够好到可以真正发挥作用。我该怎么办？

我已经尝试了上面提到的 4 种解决方案

c++

3 个回答

  1. Best Answer

    我相信一个例子胜过一千个抽象的词语。看看我列举的一些例子：

    #include <iostream>
#include <thread>
#include <vector>
#include <atomic>
#include <mutex>
#include <memory>
#include <array>

constexpr int POOL_SIZE = 100;

class MemoryPool {
public:
    MemoryPool() {
        for (auto& obj : pool) {
            obj = std::make_unique<Object>();
        }
    }

    std::unique_ptr<Object> acquire() {
        std::scoped_lock lock(mtx);
        for (auto& obj : pool) {
            if (obj) {
                std::unique_ptr<Object> tmp = std::move(obj);
                return tmp;
            }
        }
        return nullptr;
    }

    void release(std::unique_ptr<Object> obj) {
        std::scoped_lock lock(mtx);
        for (auto& slot : pool) {
            if (!slot) {
                slot = std::move(obj);
                break;
            }
        }
    }

private:
    struct Object {};
    std::array<std::unique_ptr<Object>, POOL_SIZE> pool;
    std::mutex mtx;
};

std::atomic<int> counter{0};
MemoryPool memoryPool;

void worker() {
    for (int i = 0; i < 1000; ++i) {
        auto obj = memoryPool.acquire();
        if (obj) {
            counter.fetch_add(1, std::memory_order_relaxed);
            memoryPool.release(std::move(obj));
        }
    }
}

int main() {
    std::vector<std::thread> threads;
    for (int i = 0; i < 8; ++i) {
        threads.emplace_back(worker);
    }
    for (auto& t : threads) {
        t.join();
    }
    std::cout << "Counter: " << counter.load() << std::endl;
    return 0;
}

    该池允许高效的对象分配和释放，而无需频繁的堆分配，这在多线程应用程序中可能会很昂贵。

    Constructor: Initializes the pool with POOL_SIZE number of Objects.

acquire(): Acquires a Object from the pool in a thread-safe manner using std::scoped_lock.

release(): Releases the Object back to the pool, also using std::scoped_lock.

Mutex (mtx): Ensures thread-safe access to the pool.

counter: Keeps track of the number of successful acquire() calls.

memoryPool: An instance of MemoryPool.

Thread Creation: Creates and starts 8 threads.

Thread Joining: Waits for all threads to finish.

Output: Prints the value of counter.

    每个工作线程尝试获取一个对象 1000 次。如果成功，它会递增计数器并将对象释放回池中。我演示了一个线程安全的内存池，具有高效的对象分配和释放。std::scoped_lock这里的使用确保一次只有一个线程可以访问池，从而防止数据争用。std::atomic counter提供了一种无锁的方式来计算成功的对象获取！我希望你能理解。

    • 2

  2. 这个问题真的很有趣。我以前也处理过这个问题，希望能和大家分享一下！

    1. 您应该使用对象池来实现增强的内存池。使用更复杂的内存池机制来高效地回收对象。
    2. 我经常使用 ThreadSanitizer（LLVM 的一部分）来检测运行时的数据竞争 :)。这将对你有很大帮助！
    • 1

  3. 如果我正确理解了你的问题，答案就简单多了。

    您可以将指针作为参数传递给线程：

    
#include <iostream>
#include <thread>
#include <atomic>

using namespace std;

void task(std::atomic<int> *inc)
{
    for (int i = 0; i < 5000; ++i)
        ++*inc;
}

int main()
{
    std::atomic<int> inc(0);

    std::thread t1(task, &inc);
    std::thread t2(task, &inc);

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

    std::cout << inc << std::endl;

    return 0;
}

    输出 ：

    10000

    或者，如果所有线程都使用相同的功能，则可以使用一个static变量（该变量仅初始化一次，并保存在内存中直到程序执行结束）：

    
#include <iostream>
#include <thread>
#include <atomic>

using namespace std;

void task()
{
    static std::atomic<int> inc(0);
    for (int i = 0; i < 5000; ++i)
        ++inc;
    std::cout << inc << std::endl;
}

int main()
{
    std::thread t1(task);
    std::thread t2(task);

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

    return 0;
}

    输出 ：

    6119 # Variable
10000

    存储持续时间是程序的整个执行过程，存储在对象中的值仅在主函数之前初始化一次。所有声明为静态的对象以及所有未声明为 _Thread_local（直到 C23）thread_local（自 C23 起）（自 C11 起）且具有内部或外部链接的对象都具有此存储持续时间。

    C++ 参考

    • 0

相关问题