Обработка события в текущей нити

Question

У меня есть функция f1, которая работает в потоке, и она непрерывно выполняет расчет c1.

Но когда к нему приходит специальное событие, f1 должен выполнить расчет c2 (вместо вычисления c1).

Как это реализовать? Я много искал, случай производителя-потребителя или условные блокировки не подходят для моей реализации (я так думаю), потому что я не хочу, чтобы поток останавливался до тех пор, пока событие не произойдет.

Может кто-нибудь мне помочь?

Спасибо заранее

class myclass 
{ 
    void f1 (void) 
    { //I do not want the f1 stop, it has to do its work, and when f2 send an event to him, act different 
     while (1) { 
      if(there is an event from f2) 
       do c2; 
      else 
       do c1; 
      // I do not want to loose any event either 
     } 
    } 

    void f2(void) 
    {//f2 runs in parralel to f1 
    } 

    void execute() 
    { 
     // f1_thread do calculations (c1) continiously 
     boost::thread* f1_thread = new boost::thread(boost::bind(&myclass::f1, this)); 
     // f2_thread has to send an event to force the f1_thread (once a while) to do calculation c2 instead of c1 
     boost::thread* f2_thread = new boost::thread(boost::bind(&myclass::f2, this)); 
    } 
} 
int main() 
{ 
    myclass _myclass; 
    _myclass.execute(); 
} 

Я хочу «F1» стоп «c1» расчеты и сразу же перейти на расчет c2, когда «f2» послать ему сигнал (я не знаю, о сигналах пока). расчет c1 очень трудоемкий, и если я использую предложение «if», когда происходит событие, «c2» не может быть запущен до тех пор, пока не закончится «c1».

Answer 1

Пока еще информация не задана в вопросе, вы пробовали какие-либо изменения в теме «простая замена указателя функции»?

typedef void (*CALC_FUNC)(); 

void c1() { ... } 
void c2() { ... } 
volatile CALC_FUNC calcFunc; 

class myclass 
{ 
    void f1 (void) 
    { 
     while (1) { 
      // Provided that your platform's function pointer 
      // assigment is atomic (otherwise do an interlocked 
      // operation) 
      CALC_FUNC func = calcFunc; 
      func(); 
     } 
    } 

    void f2(void) 
    { 
     // Provided that your platform's function pointer 
     // assigment is atomic (otherwise do an interlocked 
     // operation) 
     if(someCondition) calcFunc = c2; 
     else if(someOtherCondition) calcFunc = c1; 
    } 

    void execute() 
    { 
     calcFunc = c1; 

     // f1_thread do calculations (c1) continiously 
     boost::thread* f1_thread = new boost::thread(boost::bind(&myclass::f1, this)); 
     // f2_thread has to send an event to force the f1_thread (once a while) to do calculation c2 instead of c1 
     boost::thread* f2_thread = new boost::thread(boost::bind(&myclass::f2, this)); 
    } 
}