![Promises -- loops
function doSomethingConc(n) {
var futures = []
for (var i = 0; i < n; ++i) {
futures.push(doSlow(i));
}
// returns a new future, which
// resolves to an array of results
return Promise.all(futures);
}
function doSomethingSeries(n) {
var future = Promise.resolved(null);
var every = (i) => {
future = future.then(() => doSlow(i));
}
for (var i = 0; i < n; ++i) {
every(i);
}
return future;
}](https://image.slidesharecdn.com/theartofconcurrentprogramming-161116150719/85/The-art-of-concurrent-programming-12-320.jpg)
The art of concurrent programming
- 1. The Art of Concurrent Programming Past, Present and Future Iskren Chernev
- 2. What is this talk about â What is parallel, concurrent, asynchronous â Brief history â Run Loops â Callbacks â Promises â Coroutines
- 3. Parallel, Concurrent, Asynchronous â Parallel - 2 pieces of code running at the same time (threads/processes running different CPUs, cores) â Concurrent - the begining and end of 2 pieces of code overlap, but not necessarily run at the same time (could be parralel, but not necessarily). So it appears to overlap, but it doesnât have to â Asynchronous - an operation that will complete at a later time, but its execution doesnât block the thread/process â Weâll cover Asynchronous programming in this lecture
- 4. Brief overview of the environment â Obviously this talk is opinionated, so hereâs what I have in mind â server-side business logic applications â little amount of computation â A lot of IO (talking to other (micro)-services and databases) â A huge volume of âeasyâ requests â Client side is also mostly event driven with little computation so most of talk applies there too
- 5. Brief History â Single Threaded software â Mutli-core brought with it Multi Threaded Software â (+) Its very close to single threaded software â (-) slow context switch, creation â (-) cache trashing â (-) need for synchronization primitives -- this is complicated â With Node.js (2009) came the hype around asynchronous, single threaded programming â After that most other popular languages added asynchronous primitives and libraries as standard, or popularized and extended existing asynchronous primitives (Java, C#, Objective-C, Python)
- 6. So what is this Node.js all about var server = http.createServer((request, response) => { response.end( 'It Works!! Path Hit: ' + request.url); }) server.listen(PORT, () => { console.log("Server listening on: http://localhost:%s" , PORT); })
- 7. Node.js - basic function doSomethingSync(args) { r = doSlow1(args); return doSlow2(r) } function doSomething(args, done) { doSlow1(args, (err, res) => { if (err) return done(err); doSlow2(res, done); }); } â Easy function creation with âclosuresâ is a must â Every async computation calls a given function after finished
- 8. What else - letâs try an if function doSomethingSync(args) { if (cond) { r = doSlow1(); } else { r = 5; } doFast(r); return doSlow2(); } WTF function doSomething(args, done) { var doRest = (r, done) => { doFast(r) doSlow2(done) } if (cond) { return doSlow1((err, res) => { if (err) return done(err) doRest(arg, done) }) } doRest(5, done); }
- 9. Key takeaways from Node.js â Its great because it showed the world what asynchronous code looks like and how to do it with callbacks â It sucks to actually code it (there is async.js but its still pretty painful) â Is here a better way? â (pro) its very fast â (pro) all libraries support callback async interface â (cons) writing correct async-callback code is tricky to do right (easy to double call the callback, or not call it at all, or forget to return when calling done â (cons) and its ugly (deep nesting for a chain of async operations)
- 10. Run Loops â Something like a thread manager â Operations a run loop should implement â schedule(fn) -- this function only is enough to implement basic concurrent systems with multithreaded blocking IO (main thread) â scheduleLater(when, fn) -- similar to schedule but executes at a later point â addSocketWithEvents(sock, evmask, fn) - register for socket events â NOTE: that linux support for async DISK io is spotty, and is mostly wrapped with thread pool under the hood â Run loops are the basis of asynchronous programming â You can have one or many, and communicate between them using schedule â Node.js has a run-loop built in, but other languages added those later â Libraries should explicitly support run loops (if there are many), and most âoldâ languages, âoldâ libraries are blocking â You could shim any blocking operation with a thread pool and a single main run-loop
- 11. What is a Promise â Called in different ways : Future, CompletionStage (Java), Task (C#) etc â Its an object representing the result of an asynchronous operation â It supports chaining function doSomethingSync(args) { if (cond) { r = doSlow1(); } else { r = 5; } doFast(r); return doSlow2(); } function doSomething(args) { if (cond) { r = doSlow1(); } else { r = 5; } Promise.resole(r).then((r) => { doFast(r); return doSlow2(); }); }
- 12. Promises -- loops function doSomethingConc(n) { var futures = [] for (var i = 0; i < n; ++i) { futures.push(doSlow(i)); } // returns a new future, which // resolves to an array of results return Promise.all(futures); } function doSomethingSeries(n) { var future = Promise.resolved(null); var every = (i) => { future = future.then(() => doSlow(i)); } for (var i = 0; i < n; ++i) { every(i); } return future; }
- 13. Promisses - notes â Error propagation â If you need to exit early from a chain you have to use exceptions â Compared to callbacks -- promisses guarantee listener is called at most once â So callbacks are still necessary if you need to call listener many times â In some languages (C++, some JS libs), promise and future are separate object â In typed languages (C++, Java, C#) you need a few different APIs on the promise to handle async and sync returns â Normally the listener is called right after its produced, on the same thread, but you can change that â Promises are hard to implement -- use an official/stable lib, do NOT do it yourself
- 14. Coroutines â Coroutines are mostly syntax sugar on top of promises, but it pays off! â The observation is that mostly you have a linear chain of promises, so in that case you can use a keyword await (C#, python) / yield (python) â It handles linear code, ifs and serial loops â You can always fall back to promises if what youâre doing is more complicated (branches off, parralel loops) â To implement you need support in the language async def doStuff(x): if cond: r = async doSlow(x) else: r = 5 doFast(r) return async doSlow()