Sendable protocol for thread safety in Swift - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of the Sendable protocol in Swift?

The Sendable protocol marks types as safe to be used across different threads without causing data races or undefined behavior.

intermediate

How does Swift check if a type conforms to Sendable?

Swift uses compile-time checks to ensure that all stored properties of a type are also Sendable, making the whole type safe for concurrent use.

intermediate

Can classes conform to Sendable automatically? Why or why not?

No, classes do not automatically conform because they have reference semantics and can cause data races. You must manually ensure thread safety and mark them as Sendable if safe.

beginner

What keyword do you use to declare a type as conforming to Sendable?

You use the Sendable protocol in the type declaration, for example: struct MyType: Sendable { ... }.

beginner

Why is Sendable important in Swift concurrency?

Sendable helps the compiler ensure that data passed between concurrent tasks is safe, preventing bugs caused by simultaneous access to mutable state.

What does the Sendable protocol guarantee in Swift?

A That a type is immutable

B That a type can be safely shared across threads

C That a type is a class

D That a type is only used on the main thread

Sendable ensures a type is safe to use across threads, not necessarily immutable or restricted to the main thread.

Which of these types automatically conforms to Sendable in Swift?

A Structs with only <code>Sendable</code> properties

B All classes

C Functions

D Enums with associated reference types

Structs with only Sendable properties automatically conform. Classes and enums with reference types do not.

If a class has mutable state, can it conform to Sendable safely without extra work?

A Only if it inherits from NSObject

B Yes, always

C No, you must ensure thread safety manually

D Only if it is final

Mutable state in classes requires manual thread safety measures before conforming to Sendable.

What happens if you try to pass a non-Sendable type between concurrent tasks?

A The program crashes immediately

B Nothing, it works fine

C The type is automatically copied

D The compiler will produce an error or warning

Swift's compiler checks and warns or errors if non-Sendable types are passed between concurrent contexts.

Which keyword is used to declare a type conforms to Sendable?

A Sendable

B threadsafe

C sendable

D concurrent

The protocol name Sendable is used exactly as is in the type declaration.

Explain what the Sendable protocol is and why it matters for thread safety in Swift.

Think about how Swift prevents data races when sharing data between threads.

Describe how you would make a custom struct conform to Sendable safely.

Consider what properties your struct has and their thread safety.