c++ - 使用c++类成员函数作为c回调函数，线程安全版本

Question

The original question ，得到了关于如何做非线程安全版本的很好的答案。

这是代码，我试图稍微修改一下以开始工作:

#include <stdio.h>
#include <functional>
#include <thread>

void register_with_library(int (*func)(int *k, int *e)) {
   int x = 0, y = 1;
   int o = func(&x, &y);
}

typedef int (*callback_t)(int*,int*);

class A {
  template <typename T>
  struct Callback;

  template <typename Ret, typename... Params>
  struct Callback<Ret(Params...)> {
     template <typename... Args>
     thread_local static Ret callback(Args... args) {
        func(args...);
     }
     thread_local static std::function<Ret(Params...)> func;
  };
   public:
      A();
      ~A();
      int e(int *k, int *j);
    private:
      callback_t func;
};

template <typename Ret, typename... Params>
thread_local std::function<Ret(Params...)> A::Callback<Ret(Params...)>::func;

A::A() {
   Callback<int(int*,int*)>::func = std::bind(&A::e, this, std::placeholders::_1, std::placeholders::_2);
   printf("1.  C callback function ptr %p, C++ template function ptr %p Object ptr %p \n",func, Callback<int(int*,int*)>::func,  this) ;
   func = static_cast<callback_t>(Callback<int(int*,int*)>::callback);
   printf("2.  C callback function ptr %p\n",func) ;
   register_with_library(func);
}

int A::e(int *k, int *j) {
   return *k - *j;
}

A::~A() { }

int main() {
   std::thread t1 = std::thread { [](){ A a;}};
   std::thread t2 = std::thread { [](){ A a;}};

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

结果是

function ptr 0x400eef
function ptr 0x400eef

考虑到我有多个线程创建不同的对象，如何让它正常工作以为每个新对象创建新的回调？

编辑:

正如 e.jahandar 所建议的那样，使用 thread_local 可以部分解决问题(仅当每个线程创建 1 个对象时)。多亏了这个，Callback<int(int*,int*)>::func以线程为基础进行分配。虽然，问题仍然存在 Callback<int(int*,int*)>::callback .

没有 thread_local:

1. C callback function ptr 0x403148, C++ template function ptr 0x609180 Object ptr 0x7ff9ac9f3e60 
2. C callback function ptr 0x403673
1. C callback function ptr 0x4031a6, C++ template function ptr 0x609180 Object ptr 0x7ff9ad1f4e60 
2. C callback function ptr 0x403673

使用 thread_local :

1. C callback function ptr 0x403230, C++ template function ptr 0x7fc1ecc756d0 Object ptr 0x7fc1ecc74e20 
2. C callback function ptr 0x403701
1. C callback function ptr 0x4031d2, C++ template function ptr 0x7fc1ec4746d0 Object ptr 0x7fc1ec473e20 
2. C callback function ptr 0x403701

Answer 1

如果每个线程只需要一个特定对象的实例，您可以使用一个全局变量作为对象指针和__thread 存储类，__thread 使全局变量对于该线程是唯一的。

使用带有静态成员的单调类进行回调是另一种解决方案，与之前的解决方案一样，您可以使用 __thread 为每个线程分离单调类实例。

还要注意，__thread 不是标准的东西

编辑

举个例子

类.h

class someClass{
     private:
         someMethod(){ ... }
}

类.cpp

__thread void * objectPointer;

void initialize(){
    someClass * classPtr = new someClass();
    objectPointer = (void *) classPtr;
}

void * callbackFunction(void * args){
    someClass * obj = objectPointer;
    obj->someMethod();
}