C++ 线程：从主线程触发循环

Question

I have 4 sensors that I would like to poll asynchronously inside 4 different threads. I have a timer that will call a function at 30Hz and I would like this function to trigger the polling inside the threads.

I have tried using std::async to spawn 4 threads each time the timer calls but the overhead of creating the threads is too much. Here is what I did with std::async :

for (auto& camera : camera_vector_) {
  camera_asyncs_.emplace_back(
      std::async(std::launch::async, [camera]() -> bool {
          return camera->poll();
      })
  );
}

for (auto& future : camera_asyncs_) {
  future.get();
}

---

Now I need my 4 threads to be spawned at the start of the program and wait for the clock to tell them to unlock and run the process function. something like this:

for (auto& camera : camera_vector_)
{
  camera_threads_.emplace_back(std::thread([&camera]() {
    while (true)
    {
      wait_for_trigger();
      camera->poll();
      block_trigger();
    }
  }));
}

void Driver::poll_threads() {
  for (auto& thread : camera_threads_) {
    trigger_thread(thread);
  }
}

How would you do this? my research led me to mutexes, and condition variables. For example here . But the examples I found were to start a bunch of threads and let them finish. not to trigger one loop in one thread at a time.

Also it seems that what I need here is not a thread pool, because each thread as a defined job that just need a trigger. Am I correct?

It seems to me that using mutexes is the right thing to do. Should I store them in a second vector the same size as my thread vector? I know I can lock a mutex inside the thread, but can I unlock the mutex from the main thread? Do you have any tips for implementing this?

I am using C++14.

Thanks for your help.

Answer 1

Here is my understanding about your need:

1. You just need four threads, no more no less;
2. The four threads are independent each other, meaning that they don't share data;
3. Each thread is triggered and do job every 33ms, in one 33ms, it can't do job more than once;
4. If a thread is still working on the last job while the trigger happening, the thread is allowed to ignore this trigger.

I will do the design as below:

#include <thread>
#include <vector>
#include <chrono>
#include <iostream>
#include <atomic>

using namespace std;

std::atomic_flag lock0 = ATOMIC_FLAG_INIT;
std::atomic_flag lock1 = ATOMIC_FLAG_INIT;
std::atomic_flag lock2 = ATOMIC_FLAG_INIT;
std::atomic_flag lock3 = ATOMIC_FLAG_INIT;

void trigger() {
    while (true) {
        lock0.clear(); // set to false
        lock1.clear(); // set to false
        lock2.clear(); // set to false
        lock3.clear(); // set to false
        std::this_thread::sleep_for(std::chrono::milliseconds(33)); // 33 ms = 1000ms/30
        // from now on, all threads lost the chance to be triggered
        // they have to wait for the next time
        lock0.test_and_set(); // set to true
        lock1.test_and_set(); // set to true
        lock2.test_and_set(); // set to true
        lock3.test_and_set(); // set to true
    }
}

void f0()
{
    while (true) {
        while(!lock0.test_and_set()) {
            std::cout << "f0" << std::endl;
        }
    }
}

void f1()
{
    while (true) {
        while(!lock1.test_and_set()) {
            std::cout << "f1" << std::endl;
        }
    }
}

void f2()
{
    while (true) {
        while(!lock2.test_and_set()) {
            std::cout << "f2" << std::endl;
        }
    }
}

void f3()
{
    while (true) {
        while(!lock3.test_and_set()) {
            std::cout << "f3" << std::endl;
        }
    }
}

int main()
{
    std::vector<std::thread> v; // use std::async if you want
    std::thread t(trigger);
    v.emplace_back(f0);
    v.emplace_back(f1);
    v.emplace_back(f2);
    v.emplace_back(f3);
    for (auto &ele : v) {
        ele.join();
    }
    t.join();

    return 0;
}

This code won't block, instead, it would keep running and do nothing untill the trigger comes.