The diagram does seem quite complicated. I find a king analogy quite perfect in this context to have a grey level understanding about how event-loop works. Imagine the code you want to run is a king and node is the army of servants. The day starts by one servant waking up the king and asking … Read more
In this case, there is no way to cancel the Future once it has actually started running, because you’re relying on the behavior of concurrent.futures.Future, and its docs state the following: cancel() Attempt to cancel the call. If the call is currently being executed and cannot be cancelled then the method will return False, otherwise … Read more
Each event loop has a microtask queue and a macrotask queue. A microtask is a task that is originally to be queued on the microtask queue rather than a task queue. Refer to https://www.w3.org/TR/html51/webappapis.html#microtask-queue. There are two kinds of microtasks: solitary callback microtasks, such as Promiseļ¼ and compound microtasks, such as Object.observe, MutationObserver and process.nextTick … Read more
Why “1” is after “b”? The promise specification states that all promise .then() handlers must be called asynchronously after the call stack has emptied. Thus, both a and b, which are executed synchronously on the call stack will execute before any .then() handlers so 1 will always be after a and b. Some interesting reading: … Read more
TL;DR: Because += reads x before, but writes it after it has changed, due to the await keyword in its second operand (right-hand side). async functions run synchronously when they are called until the first await statement. So, if you remove await, it behaves like a normal function (with the exception that it still returns … Read more
When you join the new thread in the main thread, it will wait until the thread finishes, so the GUI will block even though you are using multithreading. If you want to place the logic portion in a different class, you can subclass Thread directly, and then start a new object of this class when … Read more
I used to wonder a lot about the same! A GUI main loop looks like this, in pseudo-code: void App::exec() { for(;;) { vector<Waitable> waitables; waitables.push_back(m_networkSocket); waitables.push_back(m_xConnection); waitables.push_back(m_globalTimer); Waitable* whatHappened = System::waitOnAll(waitables); switch(whatHappened) { case &m_networkSocket: readAndDispatchNetworkEvent(); break; case &m_xConnection: readAndDispatchGuiEvent(); break; case &m_globalTimer: readAndDispatchTimerEvent(); break; } } } What is a “Waitable”? Well, it’s … Read more
Remember that while JavaScript is single-threaded, all of node’s I/O and calls to native APIs are either asynchronous (using platform-specific mechanisms), or run on a separate thread. (This is all handled through libuv.) So when there’s data available on a socket or a native API function has returned, we need a synchronized way to invoke … Read more
I have been personally reading the source code of node.js & v8. I went into a similar problem like you when I tried to understand node.js architecture in order to write native modules. What I am posting here is my understanding of node.js and this might be a bit off track as well. Libev is … Read more
1: If we are talking about a single-threaded application, then what processes setTimeouts while JS engine accepts more requests and executes them? Isn’t that single thread will continue working on other requests? Then who is going to keep working on setTimeout while other requests keep coming and get executed. There’s only 1 thread in the … Read more