Concurrency by Tutorials

The book that teaches you everything there is to know about how to write performant and concurrent code using GCD for your iOS apps. By Scott Grosch.

Read for Free with the Personal Plan* * Includes this and all other books in our online library See all benefits

Buy Individually $59.99* *Includes access to all of our online reading features.

4.5 (2) · 2 Reviews

Download materials

Buy paperback—Amazon Comments

Save for later

Who is this for?

This book is for intermediate iOS developers who already know the basics of iOS and Swift development but want to learn how to make their app efficiently perform tasks without affecting performance, and how to properly divide work to utilize hardware to the fullest extent.

Covered concepts

Grand Central Dispatch
Operations & Operation Queues
Common Concurrency Problems
Threads & Thread Sanitizer

Dive Into Concurrency in Your iOS Apps!

What is concurrency, and why would you even want to use it in your apps? Find out everything you need to know in this book. Learn about Grand Central Dispatch, Apple’s implementation of C’s libdispatch, also known as GCD — one of the...

Before You Begin

This section tells you a few things you need to know before you get started, such as what you’ll need for hardware and software, where to find the project files for this book and more.

What You Need

Book Source Code & Forums

iii

Dedications

About the Team

Acknowledgments

Section I: Getting Started With Concurrency

In this part of the book, you’re going to learn about the basics of Concurrency. You’re going to learn what it is, what kind of problems it solves and when and how you would use it.

Furthermore, you will learn the basic pieces which comprise Concurrency in iOS development: Grand Central Dispatch and Operations.

This section will provide you with foundational knowledge regarding Concurrency, so be sure to read it through! The upcoming sections will dive much deeper into each of these concepts individually.

Introduction

Get a quick overview of what concurrency is and why you might want to use it.

GCD vs. Operations

Concurrency can be handled by either Grand Central Dispatch (GCD) or Operations. Learn about the differences.

Section II: Grand Central Dispatch

In this section, you’ll take a deep dive into Apple’s most popular and easy-to-use mechanism to write and manage concurrent tasks — Grand Central Dispatch. You’ll learn how to utilize queues and threads to control the execution of tasks in your app, as well as how to group these tasks together. You’ll also learn about common pitfalls and dangers of using concurrency, and how you can avoid them.

Queues & Threads

This chapter teaches you how to use a GCD queue to offload work from the main thread. You'll also learn what a "thread" is.

Groups & Semaphores

In the previous chapter you learned about how queues work. In this chapter you'll expand that knowledge to learn how to submit multiple tasks to a queue which need to run together as a "group" so that you can be notified when they have all completed. You'll also learn how to wrap an existing API so that you can call it asynchronously.

Concurrency Problems

By now you know how GCD can make your app so much faster. This chapter will show you some of the dangers of concurrency if you're not careful, and how to avoid them.

Section III: Operations

Even though Grand Central Dispatch provides most of the concurrency capabilties you’ll need right out-of-the-box, sometimes you’ll want some extra customizability. This is where Operations come into play. This section will teach you about Operations, Operation Queues and everything in between.

Operations

In this chapter you'll switch gears and start learning about the Operations class, which allows for much more powerful control over your concurrent tasks.

Operation Queues

Similar to the Dispatch Queues you learned about back in Chapter 3, the Operation class uses an OperationQueue to perform a similar function.

Asynchronous Operations

Now that you can create an Operation and submit it to a queue, you'll learn how to make the operation itself asynchronous. While not something you'll do regularly, it's important to know that it's possible.

Operation Dependencies

The "killer feature" of Operations is being able to tell the OS that one operation is dependent on another and shouldn't being until the dependency has finished.

Canceling Operations

There are times when you need to stop an operation that is running, or has yet to start. This chapter will teach you the concepts that you need to be aware of to support cancelation.

Section IV: Real-Life Concurrency

To wrap up this book, this section will be dedicated to showing you how you can use the knowledge you’ve accumulated throughout this book for real-life purposes.

In this section, you’ll take a deeper dive into a common case where concurrency plays a huge role — Core Data — as well as learn about Apple’s Thread Sanitizer, a great tool to debug and resolve concurrency issues and confusions.

Core Data

Core Data works well with concurrency as long as you keep a few simple rules in mind. This chapter will teach you how to make sure that your Core Data app is able to handle concurrency properly.

Thread Sanitizer

Data races occur when multiple threads access the same memory without synchronization and at least one access is a write. This chapter will teach you how to use Apple's Thread Sanitizer to detect data races.

Conclusion