Wie setze ich ein Timeout in einer Funktion, die in einem Thread läuft

Question

Ich mache eine blockierende Kommunikation mit einem Server mit einem Client. Die Funktion läuft in einem Thread. Ich möchte eine Auszeitfunktionalität festlegen. Ich verwende keinen Boost oder so etwas. Ich verwende Windows-Threading-Bibliothek.

Hier ist die Funktion, die ich eine Timeout-Funktion in ihm festlegen möchte.

bool S3W::IWFSData::WaitForCompletion(unsigned int timeout) 
{ 

    if (m_Buffer) 
    { 
     while (!m_Buffer.IsEmpty()) 
     { 
      unsigned int i = 0; 
      char gfname[255]; // must be changed to SBuffer 
      char minHeightArr[8], maxHeightArr[8], xArr[8], yArr[8]; 

      m_PingTime += timeout; 

      if (m_PingTime > PONG_TIMEOUT) 
      { 
       m_PingTime = 0; 
       return false; 
      } 

      while (m_Buffer[i] != '\0') 
      { 
       gfname[i] = m_Buffer[i]; 
       i++; 
      } 

      gfname[i] = '\0'; 

      for (unsigned int j = 0; j < 8; j++) 
      { 
       minHeightArr[j] = m_Buffer[i++]; 
      } 

      for (unsigned int j = 0; j < 8; j++) 
      { 
       maxHeightArr[j] = m_Buffer[i++]; 
      } 

      double minH = *(double*)minHeightArr; 
      double maxH = *(double*)maxHeightArr; 

      for (unsigned int j = 0; j < 8; j++) 
      { 
       xArr[j] = m_Buffer[i++]; 
      } 

      for (unsigned int j = 0; j < 8; j++) 
      { 
       yArr[j] = m_Buffer[i++]; 
      } 

      double x = *(double*)xArr; 
      double y = *(double*)yArr; 

      OGRFeature *poFeature = OGRFeature::CreateFeature(m_Layer->GetLayerDefn()); 

      if(poFeature) 
      { 
       poFeature->SetField("gfname", gfname); 
       poFeature->SetField("minHeight", minH); 
       poFeature->SetField("maxHeight", maxH); 

       OGRPoint point; 
       point.setX(x); 
       point.setY(y); 

       poFeature->SetGeometry(&point); 


       if (m_Layer->CreateFeature(poFeature) != OGRERR_NONE) 
       { 
        std::cout << "error inserting an area" << std::endl; 
       } 
       else 
       { 
        std::cout << "Created a feature" << std::endl; 
       } 
      } 

      OGRFeature::DestroyFeature(poFeature); 

      m_Buffer.Cut(0, i); 
     } 
    } 

    return true; 
} 

Es ist ein Thread, der die Daten in den Puffer

int S3W::ImplConnection::Thread(void * pData) 
{ 
    SNet::SAutoLock lockReader(m_sLock); 
    // RECEIVE DATA 
    SNet::SBuffer buffer; 
    m_data->SrvReceive(buffer); 


    // Driver code for inserting data into the buffer in blocking communication 
    SNet::SAutoLock lockWriter(m_sLockWriter); 
    m_data->SetData("ahmed", strlen("ahmed")); 
    double minHeight = 10; 
    double maxHeight = 11; 
    double x = 4; 
    double y = 2; 
    char minHeightArr[sizeof(minHeight)]; 
    memcpy(&minHeightArr, &minHeight, sizeof(minHeight)); 


    char maxHeightArr[sizeof(maxHeight)]; 
    memcpy(&maxHeightArr, &maxHeight, sizeof(maxHeight)); 


    char xArr[sizeof(x)]; 
    memcpy(&xArr, &x, sizeof(x)); 


    char yArr[sizeof(y)]; 
    memcpy(&yArr, &y, sizeof(y)); 

    m_data->SetData(minHeightArr, sizeof(minHeightArr)); 
    m_data->SetData(maxHeightArr, sizeof(maxHeightArr)); 
    m_data->SetData(xArr, sizeof(xArr)); 
    m_data->SetData(yArr, sizeof(yArr)); 

    m_data->WaitForCompletion(1000); 


    return LOOP_TIME; 
} 

Answer 1

Im Allgemeinen sollten Sie keine Threads für diese Zwecke verwenden, Denn wenn ein Thread wie dieser beendet wird, können der Prozess und die anderen Threads in einem unbekannten Zustand belassen werden. Schauen Sie sich here für die Erklärung an.

Verwenden Sie stattdessen stattdessen procceses. Lesen Sie here über das Öffnen von Prozessen in C++.

Wenn Sie Threads verwenden möchten, können Sie den Thread nach Ablauf der Zeit beenden.

Machen Sie eine Schleife (wie Sie haben), die break wird, wenn einige Zeit verstrichen ist.

#include <ctime> 

#define NUM_SECONDS_TO_WAIT 5 

// outside your loop 

std::time_t t1 = std::time(0); 

// and in your while loop, each iteration: 

std::time_t t2 = std::time(0); 
if ((t2 - t1) >= NUM_SECONDS_TO_WAIT) 
{ 
    break; // ... 
} 

Answer 2

Sie setzt kann einen Teilnehmer haben, die einen Zeitstempel hält (wenn Timeout, seinen Wert auf currentTime + intervalToTimeout). In WaitForCompletion(), aktuelle Uhrzeit abrufen und mit der Timeout-Zeit vergleichen.

Ich nehme an, in Ihrem Code, m_PingTime ist die Zeit, die Sie die Kommunikation starten. Sie möchten eine Zeitüberschreitung nach 1000 ms. Was Sie tun müssen, ist, in WaitForCompletion():

while (!m_Buffer.IsEmpty()) 
{ 
    ... 
    long time = getCurrentTime(); // fake code 
    if (m_PingTime + timeout < time) 
    { 
     m_PingTime = 0; 
     return false; 
    } 
    ... 
} 

Answer 3

Hier ist etwas, das ich habe, wenn Sie es selbst implementieren möchten:

clock_t startTime = clock(); 
clock_t timeElapsed; 
double counter; 
while(true){ 
    if(counter>=10){ 
     //do what you want upon timeout, in this case it is 10 secs 
    } 
    startTime = clock(); 
}