Question

我有一些运行网络数据交换的类的对象。我需要尽可能精确地在线程中启动网络操作。这以微秒为单位。在工作开始时，线程已经创建并运行。为了同步，我使用静态原子变量。在主线程中创建的对象然后在其他线程中创建的对象将启动这些对象的on_start（）函数。

class NetSender {
public: 
  static std::atomic_flag start;
  static std::atomic<uint8_t> net_sender_count;
  void on_start(){
    //... do some work
    net_sender_count++;        
    //waiting start of other 
    while(start.test_and_set())
        ;
    m_start_message = std::chrono::system_clock::now();
    //do very important job here
  }
}

和main（）函数中的某处

std::vector<NetSender*> senders[how_much_we_need];
//create senders items

std::vector<std::thread> senderthreads[how_much_we_need]; 
// for senders
senderthreads.at(i) = new std::thread(
                &NetSender::on_start,senders.at(i));
while(senders[1]->net_sender_count < how_much_we_need)
     ; //whait starting of all threads

senders[1]->start.clear();    //start job

（也许我的示例中有一些错别字，但我希望这个想法很明显）

之后，我比较m_start_message值，并且差是从10微秒到100毫秒。有没有办法将这种差异减少到微秒？或可能存在一些逻辑错误。

Answer 1

您需要一个条件变量和一个互斥体组合。

类似以下内容：

class NetSender
{
    static std::condition_variable _cvThreads; // threads signal this cv when ready
    static std::condition_variable _cvMain;    // main signals this cv after setting start condition
    static std::mutex _mutex;
    static bool _isStarted;
    static int net_sender_count;
    static int how_much_we_need;

    void on_start()
    {
        { // enter lock
            std::lock_guard<std::mutex> lck(_mutex);
            net_sender_count++;
        } // exit lock

        _cvThreads.notify_all();  // notify main thread that this worker thread is ready

        // wait for main thread to signal start
        { // enter lock
            std::lock_guard<std::mutex> lck(_mutex);

            while (_isStarted == false)
            {
                _cvMain.wait(lck); // atomically release mutex, wait for notify, then lock and continue
            }

        } // exit lock

        m_start_message = std::chrono::system_clock::now();
        //do very important job here
    }

然后在您的主线程中

NetSender::_isStarted = false;

senderthreads.at(i) = new std::thread(&NetSender::on_start,senders.at(i));

// wait for all threads to get ready
{
    std::lock_guard<std::mutex> lck(NetSender::_mutex);
    while (NetSender::net_sender_count < NetSender::how_many_we_need)
    {
         NetSender::_cvThreads.wait();
    }
    NetSender::_isStarted = true;
}

NetSender::_cvMain.notify_all(); // signal all threads to start

Answer 2

一些提示使其起作用：

1）如果要执行多次，则可能要使用线程池。

2）您可能不希望使用等待/通知，因为这将在调度/调度线程时引入延迟。如果等待时间足够短，最好旋转一下。

3）您正在寻找的是线程屏障。有很多已知的算法，您可能想利用它们。如果这是一次执行，则倒计时锁存器可能是有利的。否则，可以重复使用诸如反向感测屏障之类的屏障。如有必要，请使用树形屏障来最大程度地减少核心之间的一致性流量。

一个简单的实现可能看起来像这样（伪代码，对不起，自从我写C ++已经有一段时间了）：

void main() {

  // Create a barrier sufficient for syncing worker threads + main thread
  MyBarrier * b = new MyBarrier(num_threads + 1);

  std::thread threads[num_threads];

  for (int i = 0; i < num_threads; i++) {
    threads[i] = thread(onStart, &senders[i], b);
  }

  someWork();

  barrier->wait();

  ...
}

void onStart(NetSender *sender, MyBarrier * b) {

  doSomeWork();

  b->wait();

  doSomeMoreWork(); 
}

class MyBarrier {

private:

  std::atomic<int> count;

public:

  MyBarrier(int countdown) {
    std::atomic_init(&count, countdown);
  }

  void wait() {

    count.fetch_sub(1);

    while (count.get() > 0) {
      // spin
    }
  }
}

高精度线程同步

2 个答案: