使用两个线程运行和打破无限循环 [英] Run and break an infinite loop using two threads

问题描述

我正在尝试运行一个循环，直到用户选择中断为止.无论用户是要整夜运行该功能还是仅运行几秒钟，都应重复该循环，直到用户决定停止该功能为止.

I am trying to run a loop until the user chooses to break out of it. Whether the user wants to run the function all night or for just a few seconds the loop should repeat until the user decides to stop it.

在研究解决方案时，我遇到了使用两个线程来实现这一点的情况.第一个线程将运行无限循环，而第二个线程将等待用户输入.收到该输入后，第二个线程将终止第一个线程，然后返回.

In researching solutions I came across using two threads to achieve this. The first thread would run the infinite loop while the second thread waited for user input. Upon receiving that input the second thread would terminate the first and then return.

• 如何使用第二个线程终止第一个线程?

#include <iostream>
#include <iomanip>
#include <ctime>
#include <thread>
#include <cstdlib>
#include <Windows.h>

using namespace std;

void timeCount()
{
    time_t rawTime;
    struct tm * timeinfo;

    do
    {
        Sleep(500);
        system("cls");
        time(&rawTime);
        cout << "Seconds passed this epoch:" << rawTime << endl << endl;
        timeinfo = localtime(&rawTime);
        cout << "The local time is:" << asctime(timeinfo) << endl;
        timeinfo = gmtime(&rawTime);
        cout << "The UTC time is :" << asctime(timeinfo) << endl;
    } while (1 != 0);

};

void getStop()
{
    system("pause");
};

void timeSince()
{
    thread counter(timeCount);
    thread stopper(getStop);
    counter.detach();
    stopper.join();

    counter.~thread();
};

推荐答案

我通常使用atomic<int>或atomic<bool>来做到这一点.

I usually use an atomic<int> or atomic<bool> to do it.

线程功能

void run( atomic<bool> & quit ) {
   while (!quit) {
      // Do some work.
   }
}

---

主线程:

int main() {
   // Just to show you can do this with more than 1 extra thread.
   unsigned int nThreads = std::thread::hardware_concurrency(); 

   std::atomic<bool> loopFlags[nThreads];
   std::thread       threads[nThreads];

   // Start threads
   for ( int i = 0; i < nThreads; i++) {
       loopFlags[i] = false;
       threads[i]   = std::thread(run, std::ref(loopFlags[i]));
   }

   usleep(10000); // Sleep for a while or do something else.

   // Shutdown other threads
   for ( auto & flag : loopFlags ) {
       flag = true;
   }

   // Wait for threads to actually finish.
   for ( auto& thread : threads ) {
       thread.join();
   }
   // Resume what you were doing.
}

这篇关于使用两个线程运行和打破无限循环的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！