Как правильно работать с callback функциями в многопоточных программах?

Question

[Vi Vola]

Суть вопроса:

Есть библиотека. При создании объекта класса этой библиотеки регистрируем callback и при запуске эта библиотека создает поток, в котором он встает в блокирующее чтение чего либо, при каком то событии он вызывает наш callback. Callback должен быть либо глобальным, либо членом класса но статическим (на самом деле без разницы). Что делать, в случае, если мне нужно в теле callback изменить значение переменной val при условии, что эту переменную я не могу сделать статической?

#include "LibClass"

int my_callback(int args...) { 
    // к примеру как здесь адекватно присвоить переменной val значение
}

MyClass {
    int val;
    LibClass libclass;

public:
    MyClass() {
        libclass.register_callback(my_callback);
        libclass.run();
    }

    // ... etc 
};

UPD:
Я забыл уточнить то, что я не могу залезть в LibClass и менять реализацию, соответственно callback я тоже не могу изменить, аргументы у него всегда будут теми же

Comments

[Roman]

Кто первый встал, того и сапоги

#include <iostream>
#include <thread>
#include <mutex>
#include <chrono>

int my_callback(int& val, std::recursive_mutex& m)
{
  std::lock_guard<std::recursive_mutex> lock(m);
  for(int i = 0; i < 10; ++i)
  {
    val++;
    std::cout << val << '\t'
              << std::this_thread::get_id() << '\n';
  }
  return val;
}

int my_callback2(int& val, std::recursive_mutex& m)
{
  std::lock_guard<std::recursive_mutex> lock(m);
  for(int i = 0; i < 10; ++i)
  {
    val--;
    std::cout << val << '\t'
              << std::this_thread::get_id() << '\n';
  }
  return val;
}

class LibClass
{
  using callback = int(*)(int&, std::recursive_mutex&);
  callback cbFn[2];
  int idx;
public:
  LibClass() : cbFn{nullptr, nullptr}, idx{}{}

  void register_callback(callback cb)
  {
    cbFn[idx] = cb;
    ++idx;
  }

  void run(int& val, std::recursive_mutex& m)
  {
    std::thread t(std::ref(cbFn[0]), std::ref(val), std::ref(m));
    std::thread t2(std::ref(cbFn[1]), std::ref(val), std::ref(m));
    t.detach();
    t2.detach();
  }
};

class MyClass
{
  int val;
  LibClass libclass;
  std::recursive_mutex m;
public:
  MyClass() : val{}, libclass{}
  {
    libclass.register_callback(&my_callback);
    libclass.register_callback(&my_callback2);
    libclass.run(val, m);
  }
  void printVal()
  {
    m.lock();
    std::cout << this << " val == " << val << '\n';
    m.unlock();
  }
};

int main()
{
  MyClass m;
  std::this_thread::sleep_for(std::chrono::milliseconds(100)); // Ждем
  m.printVal();
}

[jcmvbkbc]

Roman, у тебя тут два разных объекта создают два разных потока, меняющих две разных переменных под двумя разными мьютексами. И к тому же printVal обращается к переменной не используя мьютекс. Что этот пример должен был иллюстрировать?

[Roman]

jcmvbkbc, так лучше?

[Vi Vola]

Roman, господа, но что делать в случае если LibClass писали не мы и исходников у нас нет, соответвенно callback тоже остается неизменным

[jcmvbkbc]

так лучше?

Roman, немного. sleep под мьютексом -- зло.

[jcmvbkbc]

что делать в случае если LibClass писали не мы и исходников у нас нет, соответвенно callback тоже остается неизменным

Vi Vola, регистрировать свой callback, в нём выполнять синхронизацию, а внутри вызывать чужой callback.

[Roman]

jcmvbkbc, sleep это для тормозов

[jcmvbkbc]

Roman, тормоза не поймут.

[Roman]

jcmvbkbc, ... я для задержки имел ввиду.

[jcmvbkbc]

Roman, ты так и не ответил на вопрос, что этот пример должен был иллюстрировать. Он всё ещё выглядит странно: ты рождаешь два отсоединённых потока, в которых захватываешь мьютекс и не отпускаешь его в течение 10 секунд. А в основном потоке ждёшь 10 секунд, пытаешься напечатать значение val и выйти.
Я подозреваю, что в большинстве случаев отрабатывает один поток, потом второй, а потом ты печатаешь 0, подождав 20 секунд вместо 10.
Но я не понимаю, зачем.

[Roman]

jcmvbkbc,

один поток, потом второй

Очередность не гарантирована.
Второй не получит доступа (будет ждать) пока не завершится первый (первый кто захватил).
если убрать std::lock_guard будет "каша". https://coliru.stacked-crooked.com/a/907715b91f7aa3cb

[Евгений Шатунов]

Vi Vola , из какой библиотеки этот твой LibClass взялся и какая полная сигнатура у функции register_callback?
Почему my_callback(int args...) так невнятно написан? Какая точно должна быть сигнатура?
Есть ли для register_callback семантическая пара на отмену регистрации callback-а?

[Vi Vola]

Евгений Шатунов, callback выглядит следующим образом

int slv_callback(const PPSObjAttr attr, const IPPSObjectNotify::obj_status_t stat)

Библиотека не стандартная. Но и изменить его я не могу.
И конечно же есть возможность как регистрации так и отмены регистрации кэллбэка.

[Евгений Шатунов]

Vi Vola , ты сигнатуру register_callback еще не показал. Она должна что-то возвращать, чтобы потом использовать это для отмены регистрации. Каковы тип и поведение этого возвращаемого значения?
Общий посыл таков, что ты можешь использовать эту связь для определения, какому именно объекту тебе нужно передать управление. Детали дать смогу только после ответов на мои вопросы.

[Vi Vola]

Евгений Шатунов, register_callback возвращает код выполнения - либо ok либо что то пошло не так. А unregister_callback принимает этот же callback для отмены регистрации и все. То есть регистрировать можно несколько функций. Думаю, там существует некий буфер callback-ов.

[Anton Gerasimov]

Пока что у меня ощущение, что вы попали. Если библиотека спроектированна так, что вам указатель на instance ( в явном или неявном виде) впихнуть некуда, то вы его никуда и не впихнете. Впрочем, если вы покажете полную сигнатуру register_callback (как в хедере), может, там забрезжит какая-то надежда.

Answer 1

[Anton Gerasimov]

Обычно колбэку в таких случаях передается this в качестве параметра (большинство библиотек поддерживают передачу void* параметра колбэкам). Переменную val нужно или объявить публичной, или сделать геттеры/сеттеры или объявить my_callback как friend для MyClass. Переменную нужно защитить так же, как для обычной многопоточной программы. На вскидку здесь могут подойти std::atomic или std::mutex.

Comments

[Vi Vola]

Переменную val сделать публичной недостаточно, он еще попросит сделать его статическим, соответственно то же самое с сеттерами и геттерами. Разве нет?

[Anton Gerasimov]

Нет, не совсем. Мне сейчас на самом деле пришла в голову идея получше - через лямбды (для этого нужна поддержка как минимум C++11):

MyClass {
    std::atomic<int> val;
    LibClass libclass;
     int my_callback(params...);
public:
    MyClass() {
        libclass.register_callback( [this] (params...) { my_callback(params...); });
        libclass.run();
    }

    // ... etc 
};

Если ваш компилятор поддерживает только С++98, то можно использовать boost::bind.

А то, что я имел в виду сначала - больше решение в стиле C, когда библиотека поддерживает передачу колбэку параметров. Тогда у LibClass::register_callback() будет опциональный второй параметр типа void*. Работать это будет примерно так:

int my_callback(int args..., void* priv) { 
    MyClass *instance = static_cast<MyClass*>(priv);

    instance->val = ...;
}

MyClass {
    std::atomic<int> val;
    LibClass libclass;

public:
    MyClass() {
        libclass.register_callback(my_callback, this);
        libclass.run();
    }

    // ... etc 
};

[Евгений Шатунов]

Anton Gerasimov , лямбда - это объект-функтор. У нас лямбда может быть безопасно приведена к указателю на функцию только если у лямбды пустое замыкание. Вариант с непустым замыканием не будет работать так, как хочется автору вопроса.

[Vi Vola]

Anton Gerasimov, у меня с++03 в связке с библиотеками qt 4.7
Ваши примеры можно рассмотреть в том случае если есть возможность изменить библиотеку LibClass. А что если такой возможности нет как в моем случае. Даже если есть, кэллбэк вызывается в библиотеке, то есть где то там должна быть возможность передать ему тип моего класса, который в последствии вызывает каллбэк с аргументом моего класса. Или я чего то не понимаю?

[Anton Gerasimov]

Евгений Шатунов Да, вы правы. Был уверен, что это работает, но по-видимому, я применял это только с библиотеками, которые принимают функторы.

Vi Vola В Qt с его сигналами и слотами это вообще проблемой быть не должно. Можно конкретный пример, куда вы пытаетесь передать колбэк?