释放 std::thread* 堆分配内存的正确方法是什么？

Question

我正在 class 中声明一个指向线程的指针。

class A{
   std::thread*    m_pThread;   
   bool StartThread();
   UINT DisableThread();
}

下面是我如何使用线程调用函数。

bool A::StartThread()
{
    bool mThreadSuccess = false;
    {
       try {
          m_pThread= new std::thread(&A::DisableThread, this);
          mThreadSuccess = true;
      }
      catch (...) {
         m_pDisable = false;
      }

      if(m_pThread)
      {
         m_pThread= nullptr;
      } 
   }
return mThreadSuccess;
}

这是我的线程调用的函数。

UINT A::DisableThread()
{
    //print something here.
    return 0;
}

如果我调用此 StartThread() 函数 10 次。会不会有内存泄漏？

for (i = 0; i<10; i++){
    bool sResult = StartThread();
      if (sResult) {
        m_pAcceptStarted = true;
      }
}

Answer 1

What is the correct way of freeing
m_pThread= new std::thread(&A::DisableThread, this);

释放使用分配 new 创建的非数组对象的正确方法是使用 delete.

避免裸拥有指针并避免不必要的动态分配。该示例未说明对动态存储的任何需求，理想情况下，您应该使用 std::thread 成员而不是指针。

If I call this StartThread() function 10 times. Will it have a memory leak?

即使是一次调用也会导致内存泄漏。当您在此处丢弃指针值时会发生泄漏：

m_pThread= nullptr;

could you add your better solution

这是一个：

auto future = std::async(std::launch::async, &A::DisableThread, this);
// do something while the other task executes in another thread
do_something();
// wait for the thread to finish and get the value returned by A::DisableThread
return future.get()

Answer 2

我个人更喜欢在实际项目中使用线程池，但这个示例应该让您了解如何在没有 new/delete 的情况下处理线程。

#include <iostream>
#include <thread>
#include <vector>

class A
{
public:
    template<typename Fn>
    void CallAsync(Fn fn)
    {
        // put thread in vector
        m_threads.emplace_back(std::thread(fn));
    }

    ~A()
    {
        for (auto& thread : m_threads)
        {
            thread.join();
        }
    }

    void someHandler()
    {
        std::cout << "*";
    };

private:
    std::vector<std::thread> m_threads;
};

int main()
{
    A a;

    for (int i = 0; i < 10; ++i)
    {
        a.CallAsync([&a] { a.someHandler(); });
    }
}

释放 std::thread* 堆分配内存的正确方法是什么？

What is the correct way of freeing std::thread* heap allocated memory?

c++

multithreading

c++11

stdthread