[Download the full Swift Xcode project from GitHub.]
[Download the full Objective-C Xcode project from GitHub.]
I use concurrency in most of my iOS apps, generally to keep the user interface responsive. For those of you new to iOS and/or new to computer science, “Concurrency is the notion of multiple things happening at the same time.” (We can discuss the old “What’s the difference between concurrency and parallelism?” question later.) I’m constantly being asked questions about how to implement concurrency in iOS and, most recently, I’ve received many questions about how to implement it in Swift 3. Here’s a video showing this post’s concurrent Swift code running — and notice that a UIProgressView is updating while images are downloading in the background; notice also that I’m continually pressing a button that increments an instance variable during background processing:
(Make sure you stay with me to complete this discussion of iOS concurrency in the next post. I’ll write some code in Swift 3 and Objective-C showing you the difference between serial and concurrent queues. Before coding we’ll talk about concurrency in general, the terminology used in discussing concurrency (threads, process, and tasks), the differences between the terms “concurrent” and “parallel,” the differences between serial and concurrent queues, the differences between synchronous and asynchronous methods/functions, and finally we’ll wrap up with some more definitions you need to know about.)
The questions about implementing GCD in Swift 3 have come from beginners to intermediate- to even advanced-level developers. For years, the most widely used iOS construct for concurrency — “starting tasks asynchronously” — has been Grand Central Dispatch (GCD). Most iOS old-timers like me have gotten used to GCD’s Objective-C language version of the “dispatch_async” function:
|
1 |
void dispatch_async(dispatch_queue_t queue, dispatch_block_t block); |
For example, many iOS developers have used “dispatch_async” to start the download of images “in the background.” While the images download, their apps’ user interfaces stay responsive. Once each download completes, they jump onto the “main thread” to display the image to the user. Notice I’ve placed some terms in quotes. We’ll define those terms later. My challenge to you is to research any terms with which you’re not familiar. For those of you in a hurry to find out how I now use GCD in Swift 3…
I found some URLs to very beautiful and high resolution images at NASA’s website. Then I wrote a sample project in which I download a fixed number of these images in the background and, as each image finishes downloading, I display it to the user in a UIImageView and update a UIProgressView to show the overall progress of downloading and displaying all images. Here’s a snippet of the most important method in my project showing off GCD in Swift 3:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 |
@IBAction func startAsyncImageDownload(_ sender: Any) { // Download enough images to fill in the UIImageViews on my // UIViewController; I've set each UIImageView's "tag" property // so I can access each UIImageView programmatically for i in imageViewTags { // Start each image download task asynchronously by submitting // it to the default background queue; this task is submitted // and DispatchQueue.global(_).async returns immediately. DispatchQueue.global(qos: DispatchQoS.QoSClass.default).async { // I'm PURPOSEFULLY downloading the image using a synchronous call // (NSData), but I'm doing so in the BACKGROUND. let imageView : UIImageView = self.view.viewWithTag(i) as! UIImageView let imageURL = URL(string: self.imageURLs[i-10]) let imageData = NSData(contentsOf: imageURL!) print("image tag: \(i)") // Once the image finishes downloading, I jump onto the MAIN // THREAD TO UPDATE THE UI. DispatchQueue.main.async { imageView.image = UIImage(data: imageData as! Data) self.imageCounter += 1 self.progressView.progress = Float(self.imageCounter) / Float(self.imageURLs.count) self.view.setNeedsDisplay() } // end DispatchQueue.main.async } // end DispatchQueue.global } // end for i in imageViewTags } // end startAsyncImageDownload |
Remember that a lot of iOS apps were written in Objective-C and are still being actively maintained and updated. Swift has changed so many times that developers have had to rewrite the same code multiple times. Many Apple iOS frameworks were/are written in Objective-C. While Swift is a promising new language, you should still learn — at least be knowledgeable in — Objective-C. One great advantage with using Objective-C: As new Xcode versions keep coming out, you rarely have to rewrite much code. Here’s how you would write code to achieve the same type of GCD functionality in Objective-C:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
- (IBAction)startAsyncButtonTapped:(id)sender { for (NSString *stringURL in self.listOfURLs) { dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^ { NSURL *url = [NSURL URLWithString:stringURL]; NSData *imageData = [NSData dataWithContentsOfURL:url]; UIImage *image = [UIImage imageWithData:imageData]; dispatch_async(dispatch_get_main_queue(), ^ { NSLog(@"URL: %@", [url path]); self.imageView.image = image; self.progressView.progress = (float)self.counter / (float)self.listOfURLs.count; }); }); } } |
We’re not finished discussing concurrency. See the next post in this series. I want you to do some thinking and research to find out more about “the notion of multiple things happening at the same time” in code. Specifically, please define these terms and/or concepts:
- Threads,
- Processes,
- Tasks,
- Serial,
- Concurrent,
- Queues,
- Serial queues,
- Concurrent queues,
- Queue types,
- Synchronous,
- Asynchronous,
- Concurrency versus parallelism,
- Critical sections,
- Race conditions, and
- Deadlock.
[Download the full Swift Xcode project from GitHub.]
[Download the full Objective-C Xcode project from GitHub.]
