คุณจะเพิ่มการหน่วงเวลาลงในโปรแกรม C ++ ได้อย่างไร

ฉันกำลังพยายามเพิ่มเวลาหน่วงเวลาในโปรแกรม C ++ และสงสัยว่าใครมีคำแนะนำเกี่ยวกับสิ่งที่ฉันสามารถลองทำได้หรือข้อมูลที่ฉันสามารถดูได้บ้าง

ฉันหวังว่าฉันจะมีรายละเอียดเพิ่มเติมเกี่ยวกับวิธีที่ฉันใช้การหน่วงเวลานี้ แต่จนกว่าฉันจะมีข้อมูลเพิ่มเติมเกี่ยวกับวิธีเพิ่มการหน่วงเวลาตามกำหนดเวลาฉันไม่แน่ใจว่าฉันควรจะพยายามใช้สิ่งนี้อย่างไร

Win32: Sleep(milliseconds)คือสิ่งที่คุณเป็น

unix: usleep(microseconds)คือสิ่งที่คุณต้องการ

sleep () ใช้เวลาเพียงไม่กี่วินาทีซึ่งมักจะนานเกินไป

คำตอบที่อัปเดตสำหรับ C ++ 11:

ใช้ฟังก์ชันsleep_forและsleep_until:

#include <chrono>
#include <thread>

int main() {
    using namespace std::this_thread; // sleep_for, sleep_until
    using namespace std::chrono; // nanoseconds, system_clock, seconds

    sleep_for(nanoseconds(10));
    sleep_until(system_clock::now() + seconds(1));
}

ด้วยฟังก์ชั่นเหล่านี้ไม่มีความจำเป็นต้องอย่างต่อเนื่องเพิ่มฟังก์ชั่นใหม่สำหรับการแก้ปัญหาที่ดีกว่า: sleep, usleep, nanosleepฯลฯsleep_forและsleep_untilมีฟังก์ชั่นแม่แบบที่สามารถยอมรับค่าความละเอียดใด ๆ ผ่านทางchronoประเภท; ชั่วโมงวินาที femtoseconds ฯลฯ

ใน C ++ 14 คุณสามารถทำให้โค้ดง่ายขึ้นด้วยคำต่อท้ายตามตัวอักษรสำหรับnanosecondsและseconds:

#include <chrono>
#include <thread>

int main() {
    using namespace std::this_thread;     // sleep_for, sleep_until
    using namespace std::chrono_literals; // ns, us, ms, s, h, etc.
    using std::chrono::system_clock;

    sleep_for(10ns);
    sleep_until(system_clock::now() + 1s);
}

โปรดทราบว่าระยะเวลาจริงของการนอนหลับขึ้นอยู่กับการใช้งาน: คุณสามารถขอให้นอนเป็นเวลา 10 นาโนวินาที แต่การใช้งานอาจจบลงด้วยการนอนหลับเป็นเวลาหนึ่งมิลลิวินาทีแทนหากเป็นเวลาที่สั้นที่สุด

#include <unistd.h>
usleep(3000000);

นอกจากนี้ยังจะเข้าสู่โหมดสลีปเป็นเวลาสามวินาที คุณสามารถปรับแต่งตัวเลขได้อีกเล็กน้อย

คุณต้องการอะไรง่ายๆเช่น

sleep(3);

โปรดทราบว่าสิ่งนี้ไม่ได้รับประกันว่าระยะเวลาที่เธรดเข้าสู่โหมดสลีปจะอยู่ที่ใดก็ได้ที่ใกล้เคียงกับช่วงเวลาสลีป แต่จะรับประกันได้ว่าระยะเวลาก่อนที่เธรดจะดำเนินการต่อจะเป็นจำนวนที่ต้องการเป็นอย่างน้อย ความล่าช้าที่แท้จริงจะแตกต่างกันไปขึ้นอยู่กับสถานการณ์ (โดยเฉพาะการโหลดในเครื่องที่มีปัญหา) และอาจเป็นคำสั่งของขนาดที่สูงกว่าเวลานอนที่ต้องการ

นอกจากนี้คุณไม่ได้ระบุเหตุผลที่คุณต้องนอนหลับ แต่โดยทั่วไปคุณควรหลีกเลี่ยงการใช้ความล่าช้าเป็นวิธีการซิงโครไนซ์

คุณสามารถลองใช้ข้อมูลโค้ดนี้:

#include<chrono>
#include<thread>

int main(){
    std::this_thread::sleep_for(std::chrono::nanoseconds(10));
    std::this_thread::sleep_until(std::chrono::system_clock::now() + std::chrono::seconds(1));
}

คุณยังสามารถใช้เลือก (2) หากคุณต้องการความแม่นยำระดับไมโครวินาที (ใช้ได้กับแพลตฟอร์มที่ไม่มีการหยุดทำงาน (3))

รหัสต่อไปนี้จะรอ 1.5 วินาที:

#include <sys/select.h>
#include <sys/time.h>
#include <unistd.h>`

int main() {
    struct timeval t;
    t.tv_sec = 1;
    t.tv_usec = 500000;
    select(0, NULL, NULL, NULL, &t);
}

`

ใช่การนอนหลับอาจเป็นหน้าที่ของทางเลือกที่นี่ โปรดทราบว่าเวลาที่ผ่านเข้าสู่ฟังก์ชันเป็นระยะเวลาที่น้อยที่สุดที่เธรดการโทรจะไม่ทำงาน ตัวอย่างเช่นหากคุณเรียกการนอนหลับภายใน 5 วินาทีคุณรับประกันว่าเธรดของคุณจะเข้าสู่โหมดสลีปเป็นเวลาอย่างน้อย 5 วินาที อาจเป็น 6 หรือ 8 หรือ 50 ขึ้นอยู่กับว่าระบบปฏิบัติการกำลังทำอะไรอยู่ (ระหว่างการทำงานของระบบปฏิบัติการที่เหมาะสมสิ่งนี้จะใกล้เคียงกับ 5 มาก)
คุณสมบัติที่มีประโยชน์อีกอย่างของฟังก์ชันการนอนหลับคือการส่งผ่าน 0 ซึ่งจะบังคับให้เปลี่ยนบริบทจากเธรดของคุณ

ข้อมูลเพิ่มเติมบางส่วน:
http://www.opengroup.org/onlinepubs/000095399/functions/sleep.html

ฉันพบว่า"_sleep(milliseconds);"(ไม่มีเครื่องหมายคำพูด) ทำงานได้ดีสำหรับ Win32 หากคุณรวมchronoไลบรารี

เช่น:

#include <chrono>

using namespace std;

main
{
    cout << "text" << endl;
    _sleep(10000); // pauses for 10 seconds
}

อย่าลืมใส่ขีดล่างก่อนนอน

เพื่อหน่วงเวลาเอาต์พุตใน cpp สำหรับเวลาที่กำหนดคุณสามารถใช้ฟังก์ชัน Sleep () โดยรวมไวยากรณ์ของไฟล์ส่วนหัว windows.h สำหรับฟังก์ชัน Sleep () คือ Sleep (time_in_ms) เป็น

cout<<"Apple\n";
Sleep(3000);
cout<<"Mango";

เอาท์พุท โค้ดด้านบนจะพิมพ์ Apple และรอ 3 วินาทีก่อนพิมพ์ Mango

คำตอบด้านบนดูเหมือนจะเป็นคำตอบที่ขึ้นอยู่กับระบบปฏิบัติการ สำหรับโซลูชันแบบพกพาคุณสามารถเขียนฟังก์ชันการนอนหลับอย่างรวดเร็วโดยใช้ไฟล์ส่วนหัว ctime (แม้ว่านี่อาจเป็นการใช้งานที่ไม่ดีในส่วนของฉัน)

#include <iostream>
#include <ctime>

using namespace std;

void sleep(float seconds){
    clock_t startClock = clock();
    float secondsAhead = seconds * CLOCKS_PER_SEC;
    // do nothing until the elapsed time has passed.
    while(clock() < startClock+secondsAhead);
    return;
}
int main(){

    cout << "Next string coming up in one second!" << endl;
    sleep(1.0);
    cout << "Hey, what did I miss?" << endl;

    return 0;
}

ไวยากรณ์:

เป็นโมฆะการนอนหลับ (วินาทีที่ไม่ได้ลงชื่อ);

sleep () ระงับการดำเนินการเป็นช่วงเวลา (วินาที) ด้วยการเรียกเข้าสู่โหมดสลีปโปรแกรมปัจจุบันจะถูกระงับจากการดำเนินการตามจำนวนวินาทีที่ระบุโดยวินาทีของอาร์กิวเมนต์ ช่วงเวลามีความแม่นยำถึงร้อยวินาทีที่ใกล้ที่สุดหรือความแม่นยำของนาฬิการะบบปฏิบัติการแล้วแต่ค่าใดจะแม่นยำน้อยกว่า

อื่น ๆ อีกมากมายให้ข้อมูลที่ดีสำหรับการนอนหลับ ฉันเห็นด้วยกับ Wedge ว่าการนอนหลับไม่ค่อยเป็นวิธีแก้ปัญหาที่เหมาะสมที่สุด

หากคุณกำลังนอนหลับรออะไรบางอย่างคุณควรรอสิ่งนั้น / เหตุการณ์นั้นดีกว่า ดูตัวแปรเงื่อนไขสำหรับสิ่งนี้

ฉันไม่รู้ว่าคุณกำลังพยายามทำสิ่งนี้บนระบบปฏิบัติการอะไร แต่สำหรับการทำเธรดและการซิงโครไนซ์คุณสามารถดูไลบรารีBoost Threading ( Boost Condition Varriable )

ตอนนี้ย้ายไปที่จุดสุดขีดอื่น ๆ หากคุณกำลังพยายามรอช่วงเวลาสั้น ๆ เป็นพิเศษมีตัวเลือกรูปแบบการแฮ็กสองสามแบบ หากคุณกำลังทำงานบนแพลตฟอร์มฝังตัวบางประเภทที่ไม่มีการใช้งาน 'sleep' คุณสามารถลองวนซ้ำ (สำหรับ / while ฯลฯ ) โดยใช้เนื้อความว่างเปล่า (โปรดระวังคอมไพเลอร์ไม่ได้ปรับให้เหมาะสม) แน่นอนว่าเวลารอขึ้นอยู่กับฮาร์ดแวร์เฉพาะในกรณีนี้ สำหรับ "รอ" สั้น ๆ คุณสามารถลองประกอบ "nop" ฉันสงสัยอย่างมากว่านี่คือสิ่งที่คุณเป็น แต่ไม่รู้ว่าทำไมคุณต้องรอมันยากที่จะเจาะจงมากขึ้น

ใน Windows คุณสามารถรวมไลบรารีของ windows และใช้ "Sleep (0);" เพื่อพักโปรแกรม ใช้ค่าที่แสดงถึงมิลลิวินาที