C++11 shared_ptr 和 pthread

Question

我有一个库 APIs 使用 std::shared_ptr 作为参数。

我想将这些 API 与 pthreads 一起使用。

我正在做的是：从 shared_ptr 获取原始指针，以便将其传递给 pthread。从原始的创建一个新的 shared_ptr 并从另一个线程调用我的 API。但是，在将原始指针转换回共享指针时出现 double free or corruption 错误。

这是我的代码

#include <memory>
#include <iostream>
#include <thread>
#include <pthread.h>

void* print_task(void* ptr) 
{
    int* val_raw = static_cast<int*>(ptr);
    std::shared_ptr<int> val(val_raw);

    // CALL MY API WHICH TAKES A SHARED_PTR AS ARGUMENT
    std::cout<<"thread job done \n";
}

int main(int argc, char ** argv)
{

   pthread_t thread;

   std::shared_ptr<int> val = std::make_shared<int>(10);
   pthread_create(&thread, nullptr, &print_task, static_cast<void *>(val.get()));

   std::this_thread::sleep_for(std::chrono::seconds(5));

   return 0;
}

我想我在从共享指针到原始指针的所有转换中做错了，因为使用 std::threads 的相同代码（我可以直接传递 shared_ptr）有效。但是我需要设置线程优先级，因此我正在尝试使用 pthreads 来做到这一点。

您知道如何更改我的代码以便能够传递共享指针并在 pthread 中使用它吗？

Answer 1

如评论中所述，问题是通过原始 void 指针传递共享指针，所以我暂时忽略线程部分：

// this is what we have and what we want to pass to the given function
shared_ptr<some_type> sptr;

// function to somehow pass the shared pointer to
void function(void* ptr);

// As always, when passing anything that doesn't fit into
// the raw pointer, we need to do dynamic allocation:
void* arg = new shared_ptr<some_type>(sptr);

// we can now pass this to the function as intended:
function(arg);

// Note that we give up ownership of the dynamically allocated
// shared pointer instance. Hence, the called function must
// release that object again (it takes ownership). The function
// therefore starts like this:
void function(void* ptr)
{
    // convert the typeless pointer to a typed pointer again
    shared_ptr<some_type>* psptr = static_cast<shared_ptr<some_type>*>(ptr);
    // move the content to a new, local instance
    shared_ptr<some_type> sptr = *psptr;
    // release the dynamically allocated shared pointer again
    delete psptr;
    /// ... code using sptr here ...
}

现在，虽然这保证有效，但在某些情况下这可能不是最佳解决方案：

首先，引用计数器的起伏不是免费的，尤其是因为这是以线程安全的原子方式完成的。可以避免在函数内部复制共享指针然后删除复制的指针。只需创建一个空实例并用要复制的指针交换（）它。假设 swap() 是专门的，这是一个安全的选择，因为它是一个明显的优化，然后归结为交换两个原始指针。此交换不必是线程安全的，因此速度更快。
其次，动态分配很昂贵。您可以通过将原始对象的地址传递给函数来避免这种情况和手动释放，但是您必须保证在函数仍在执行时不会触及该对象。尤其是线程，需要格外小心。

Answer 2

老实说，我认为这是一个棘手的小难题。您遇到的问题是，通过将原始指针传递给您的线程函数，您最终会得到两个独立共享指针来管理同一对象 而不是 两个 已连接 共享指针共享所有权。

因此两个共享指针都试图删除它。

你也有一个讨厌的生命周期问题要避免，如果你传递一个指向共享指针本身的指针，因为你不能保证共享指针在新线程复制它之前不会超出范围。

我通过传递从原始 std::shared_ptr 创建的 second 动态分配的 std::shared_ptr 来解决这个问题，这保证了共享指针的控制块将一直存在到新线程尝试复制它。

#include <memory>
#include <iostream>
#include <thread>
#include <pthread.h>

void* print_task(void* ptr)
{
    // obtain the shared pointer from the dynamically created one guarantees
    // we will bee accessing a living control block preventing an
    // end-of-lifetime catastrophe
    std::shared_ptr<int> val = *static_cast<std::shared_ptr<int>*>(ptr);

    // DON'T FORGET TO DELETE THIS!!!
    // We had to allocate this dynamically to guarantee it lived until after
    // it was used.
    delete static_cast<std::shared_ptr<int>*>(ptr);

    // CALL MY API WHICH TAKES A SHARED_PTR AS ARGUMENT
    std::cout << "thread job done \n";

    return nullptr;
}

int main()
{
    pthread_t thread;

    // create the shared resource. This MAY go out of scope
    // before the new thread copies it (however unlikely you
    // think that is).
    std::shared_ptr<int> val = std::make_shared<int>(10);

    // So instead of sending the shared pointer we create a NEW std::shared_ptr
    // which will keep the shared pointer's control block alive even if the original
    // shared pointer goes out of scope.
    pthread_create(&thread, nullptr, &print_task,
        static_cast<void*>(new std::shared_ptr<int>(val)));

    // Do other time consuming thread stuff here.
    std::this_thread::sleep_for(std::chrono::seconds(2));


    // Tidy up.
    void* ret = nullptr;
    pthread_join(thread, &ret);

    return 0;
}

当然，您现在在这里有一个 new/delete 对，但您仍然可以在线程之间传递共享所有权回合。

我想你甚至可以通过 temporary std::unique_ptr.

采用传入的原始指针来摆脱那个 delete

void* print_task(void* ptr)
{
    // obtain the shared pointer from the dynamically created one guarantees
    // we will bee accessing a living control block preventing an
    // end-of-lifetime catastrophe
    std::shared_ptr<int> val = *std::unique_ptr<std::shared_ptr<int>>(static_cast<std::shared_ptr<int>*>(ptr));

    // CALL MY API WHICH TAKES A SHARED_PTR AS ARGUMENT
    std::cout << "thread job done \n";

    return nullptr;
}

C++11 shared_ptr 和 pthread

C++11 shared_ptr and pthread

c++

pthreads

shared-ptr