Struct timeval now = gettimeofday() // get the current time That turns out to be very useful, because by using that parameter, the SleepUntilThereIsSomethingToDo() function can do something like this (pseudocode): void SleepUntilThereIsSomethingToDo() In particular, you can pass in a struct timeval object here that says to select(): "If no I/O events have occurred after (this many) microseconds, then you should just give up and return anyway". However, the interesting part for us is the final argument, which is a timeout-argument. Note that select() takes three different fd_set arguments, each of which can specify a number of file descriptors by passing in the appropriate fd_set objects to those arguments you can cause select() to wake up the instant an I/O operations becomes possible on any one of a set of file descriptors you care to monitor, so that your program can then handle the I/O without delay. So how does SleepUntilThereIsSomethingToDo() know when it is time to wake up and return? This will vary greatly depending on what OS you are running on, since different OS's have different APIs for handling this sort of thing, but a classic UNIX-y way to implement such a function would be with the POSIX select() call: int select(int nfds, the user moves the mouse, or presses a key, or data arrives on a socket, or etc), SleepUntilThereIsSomethingToDo() will return and then the code to respond to that event will be executed, resulting in the appropriate action such as the widgets updating or the timeout() signal being called. So when your app is idle, the process will be put to sleep inside the SleepUntilThereIsSomethingToDo() call, but as soon as an event arrives that needs handling (e.g. SleepUntilThereIsSomethingToDo() // not a real function name!ĭoTheThingsThatNeedDoingNow() // this is also a name I made up So what is going on inside that exec() call while your program is running? With a big complex library like Qt it's necessarily complicated, but it's not too much of a simplification to say that it's running an event loop that looks conceptually something like this: while(1) Note that in a typical application, almost all of the application's time will be spent inside that exec() call that is to say, the app.exec() call will not return until it's time for the application to exit. Just about every Qt program will have something like this, usually near the bottom its main() function: QApplication app(argc, argv) The key fact to know is that QTimer timeout-signal-emission only works if/when your Qt program is executing inside Qt's event loop. So having that information, what does it then do to make sure that happens? It can then add ten milliseconds (or whatever value you specified) to that time and now it has a record indicating when the timeout() signal is supposed to be emitted next. gettimeofday() or similar) to find out (to within a few milliseconds) what the time was that start() was called. The QTimer::start() method can call a system time function (e.g. Here, how does the program know when timeout() occurs? No creating a separate thread would be expensive and it isn't necessary, so that isn't how QTimer is implemented. Time and calls the timeout() function at regular intervals? Member function, is a separate thread created that keeps track of the When I create a QTimer object in Qt 5, and start it using the start() There is, but not in your program.ĭoes it mean that timeout() is handled by the OS? Is there some hardware that keeps track of the time and send interrupts at appropriate intervals? But if this is the case, as many timers can run simultaneously and independently, how can each timer be separately tracked? On searching further, I found that as per this answer by Bill, it is mentioned thatĮvents are delivered asynchronously by the OS, which is why it appears that there's something else going on. I have read the official documentation, and certain questions on StackOverflow such as this and this seem very related, but I could not get my answer through them.Ĭould anyone explain the mechanism through which a QTimer object works? However, I have been unable to find any information regarding this either in the Qt documentation or anywhere else to confirm this. Here, how does the program know when timeout() occurs? I think it would have to run in a separate thread, as I don't see how a sequential program could keep track of the time and continue its execution simultaneously. When I create a QTimer object in Qt 5, and start it using the start() member function, is a separate thread created that keeps track of the time and calls the timeout() function at regular intervals?Ĭonnect(timer,SIGNAL(timeout()),someObject,SLOT(someFunction()))
0 Comments
Leave a Reply. |
AuthorWrite something about yourself. No need to be fancy, just an overview. ArchivesCategories |