Async Techniques and Examples in Python Transcripts
Chapter: Built on asyncio
Lecture: Demo: unsync app introduction
0:00 Time to write some code with Unsync
0:02 and see how this simple, 126-line package
0:05 is going to add some incredible power
0:07 and a really wonderful API
0:09 right on top of everything we've learned.
0:11 And it's actually going to bring a lot
0:12 of what we've worked on already together so it's great.
0:16 Now let's begin by looking at the application
0:18 we're going to write code for.
0:20 Nothing we're going to do in this video
0:21 has anything to do with unsync yet.
0:23 We're going to do that in the next video.
0:25 Here we have three files
0:26 one called nosync, and that means
0:28 it has no parallelism whatsoever one called presync
0:32 and that one is going to use pure asyncio
0:35 and then there's this thesync.
0:37 It starts out using the same as presync
0:39 but we're going to convert it to the unsync API.
0:43 What we're going to do in this one
0:44 is we're just going to call these functions
0:46 and we have three, sorry four
0:48 categories of functions here.
0:49 We have one called compute_some.
0:51 If we go to compute_some you can see it's doing math
0:54 and it prints computing at the beginning, that's cool.
0:57 So this would be a CPU-bound operation.
0:59 Quick quiz, what is the best type of parallelism
1:03 to apply to this one?
1:04 asyncio, threading, or multiprocessing?
1:07 Multiprocessing, right, to do anything CPU-based.
1:10 Now we're going to download_some
1:12 we're going to download_some_more. Let's go look at those two.
1:14 In download_some, we're using requests
1:17 and in download_some_more, we're using this.
1:19 Now what we're going to imagine here
1:20 is that when we convert it over to the presync one
1:23 we'll see that for one of these
1:26 we're going to imagine that we don't have an API
1:29 that is async-enabled
1:30 but it does HTTP requests under the hood
1:33 and it's internally using requests.
1:35 We won't actually be able to await it
1:37 and it won't really take advantage of its powers
1:39 when we use it with asyncio.
1:41 The other one will have, actually
1:43 aiohttp as its client and will be properly awaitable.
1:47 So one of these would be better done with threads
1:49 and the other would be better done with asyncio.
1:52 Alright, now finally, we're just going to wait
1:55 and this just puts our thread a sleep for a while
1:57 one millisecond a thousand times, roughly one second.
2:00 And again, we could easily do this with asyncio
2:03 we've seen asyncio.sleep
2:05 and we can await that, that one would be perfect.
2:08 So this first one we're going to run has no parallelism
2:11 and let's just see how that goes.
2:15 It's computing, computing, computing
2:18 alright, it's downloading, and downloading more
2:20 then downloading and downloading more
2:22 it does that a bunch of times.
2:23 Now it's waiting, now it's done.
2:25 How long did it take?
2:26 9.62 seconds, alright, we'll freeze that
2:29 so we can come back to it.
2:31 Let's look at the presync one now.
2:33 All we've done is basically taken
2:34 as much advantage of asyncio as possible
2:37 so if you look at the functions down here
2:39 we have an async method computing
2:41 but because it's computing
2:42 we can't really do anything but wait
2:45 there's no awaitability here.
2:47 Async is not quite the proper API, as we'll see.
2:50 Now this one, this download_some
2:53 actually is, you know, is internally
2:55 like, you got to use your imagination right
2:56 internally this part actually uses aiohttp client
3:00 and we can then, you know, surface its async abilities
3:03 and this is a proper async option
3:06 so downloadings have happened great.
3:08 But this one is the one we're imagining
3:11 does not have an async API so threading would help it
3:14 but asyncio noticed there's no await keyword here
3:17 actually there's no help, alright?
3:18 This is just as if we called it in serial.
3:20 Finally, waiting, that one we used asyncio.sleep
3:23 this one's good. So let's run this one
3:25 and we'll see some things get better
3:28 like download_some, and wait_some
3:29 but compute_some and download_some_more
3:32 those, no good. Alright, that'd be a no benefit.
3:37 So we got computing, see, just as slow.
3:39 Downloading a little bit better
3:41 waiting, way better, so it's an improvement.
3:46 Notice it's about twice as fast
3:48 from 9.62 to 4.93 seconds.
3:52 Alright, so that's what we're going to start with.
3:55 We have this program
3:56 we're going to start with this presync mode
3:58 which, alright, okay we're going to pick
3:59 one of the three APIs to use. Let's pick asyncio.
4:04 And that is probably the best one
4:05 for the parts it took advantage of
4:07 but it is not the best one for, say
4:09 the compute one, or the requests based one.
4:12 So we're going to see that with the unsync API
4:15 we're going to simplify how this works
4:17 and we're going to apply the right type of parallelism
4:19 at the right place each right time.