Jordhan Léoture (Octo) - Asynchronous Swift Comment simplifier et améliorer l’asynchronisme dans nos applications ? Je vous présenterai quelques astuces afin d’exploiter au mieux GCD.

1. 34 AVENUE DE L’OPÉRA > 75002 PARIS > FRANCE > WWW.OCTO.COM
08/03/2018
ASYNCHRONOUS SWIFT
Jordhan Leoture

2. TABLE OF CONTENT
01
02
03
04
> PARALLELISM & CONCURRENCY
> FAIR LOCK & UNFAIR LOCK
> DISPATCHQUEUE
> FUTURE & PROMISE
2

3. 01 PARALLELISM & CONCURRENCY

4. PARALLELISM & CONCURRENCY
PARALLELISM
A problem is solved by multiple processors
CONCURRENCY
Many problems are solved by one processor
4

5. PARALLELISM & CONCURRENCY
Grand Central Dispatch
5
• Reduces memory for storing thread stacks
• Reduces code related to thread
management
• Simplifies code

6. PARALLELISM & CONCURRENCY
Parallelism - Example
6

7. PARALLELISM & CONCURRENCY
Parallelism - Example
6

8. PARALLELISM & CONCURRENCY
Parallelism with GCD
7
DispatchQueue.concurrentPerform(16) { i in /* iteration */ }

9. PARALLELISM & CONCURRENCY
Parallelism with GCD
8
DispatchQueue.concurrentPerform(16) { i in /* iteration */ }
UI Rendering

10. PARALLELISM & CONCURRENCY
Parallelism with GCD
9
DispatchQueue.concurrentPerform(1000) { i in /* iteration */ }
UI Rendering

11. PARALLELISM & CONCURRENCY
Concurrency - Example
10
Task #1
#3
#4
#2

12. PARALLELISM & CONCURRENCY
Concurrency - Example
11
CONTEXT SWITCH

13. PARALLELISM & CONCURRENCY
Concurrency - Example
12
CONTEXT SWITCH
• Save the context of the current thread
• Find the context of the next thread
• Reload the context of the next thread
• Resume the next thread

14. PARALLELISM & CONCURRENCY
Concurrency - Example
13
The OS chooses the next thread
• A higher priority thread needs the CPU
• The current thread finishes its work
• The current thread is waiting for a resource
• The time of the current thread has expired

15. PARALLELISM & CONCURRENCY
Concurrency - Example
14
Other process

16. PARALLELISM & CONCURRENCY
Recurring problems
15
• Frequently block threads for resource access
• Many context switch between independent operations

17. 02 FAIR LOCK & UNFAIR LOCK

18. FAIR LOCK & UNFAIR LOCK
17

19. FAIR LOCK & UNFAIR LOCK
Fair lock
18
owned reserved owned reserved

20. FAIR LOCK & UNFAIR LOCK
Unfair lock
19
owned waiters owned waiters

21. FAIR LOCK & UNFAIR LOCK
FAIR LOCK
No waiter starvation but many context switches
UNFAIR LOCK
Subject to waiter starvation but reduced context switches
20

22. FAIR LOCK & UNFAIR LOCK
21
FAIR LOCK
(dispatch_semaphore)
UNFAIR LOCK
(os_unfair_lock)
TIME BY LOCK LONG SHORT
# LOCK BY THREAD FEW MANY
# THREAD NEED THE
LOCK
MANY FEW

23. FAIR LOCK & UNFAIR LOCK
Recurring problems
22
• Frequently block threads for resource access
• Many context switch between independent operations

24. 03 DISPATCHQUEUE

25. DISPATCHQUEUE
• Perform tasks asynchronously and concurrently
• FIFO
• Thread-safe
• Serial or concurrent
24
Good to know

26. DISPATCHQUEUE
25
Quality of Service Classes
User-interactive Virtually instantaneous
User-initiated Nearly instantaneous
Default No information
Utility Seconds or few minutes
Background Minutes or hours
Unspecified Legacy APIs
High
Low

27. DISPATCHQUEUE
26
Asynchronous
queue
let queue = DispatchQueue(label: "serial-queue")
queue.async { /* block1 */ }
queue.async { /* block2 */ }
queue.async { /* block3 */ }

28. DISPATCHQUEUE
26
Asynchronous
queue Block1
let queue = DispatchQueue(label: "serial-queue")
queue.async { /* block1 */ }
queue.async { /* block2 */ }
queue.async { /* block3 */ }

29. DISPATCHQUEUE
26
Asynchronous
queue Block1
let queue = DispatchQueue(label: "serial-queue")
queue.async { /* block1 */ }
queue.async { /* block2 */ }
queue.async { /* block3 */ }
Block2

30. DISPATCHQUEUE
26
Asynchronous
queue Block1
let queue = DispatchQueue(label: "serial-queue")
queue.async { /* block1 */ }
queue.async { /* block2 */ }
queue.async { /* block3 */ }
Block2 Block3

31. DISPATCHQUEUE
26
Asynchronous
queue Block1
let queue = DispatchQueue(label: "serial-queue")
queue.async { /* block1 */ }
queue.async { /* block2 */ }
queue.async { /* block3 */ }
Block2 Block3

32. DISPATCHQUEUE
26
Asynchronous
queue
let queue = DispatchQueue(label: "serial-queue")
queue.async { /* block1 */ }
queue.async { /* block2 */ }
queue.async { /* block3 */ }
Block2 Block3

33. DISPATCHQUEUE
26
Asynchronous
queue
let queue = DispatchQueue(label: "serial-queue")
queue.async { /* block1 */ }
queue.async { /* block2 */ }
queue.async { /* block3 */ }
Block3

34. DISPATCHQUEUE
26
Asynchronous
queue
let queue = DispatchQueue(label: "serial-queue")
queue.async { /* block1 */ }
queue.async { /* block2 */ }
queue.async { /* block3 */ }

35. DISPATCHQUEUE
27
Synchronous
queue
let queue = DispatchQueue(label: "serial-queue")
queue.async { /* block1 */ }
queue.sync { /* block2 */ } // sync is a fair lock 😊
queue.async { /* block3 */ }

36. DISPATCHQUEUE
27
Synchronous
queue Block1
let queue = DispatchQueue(label: "serial-queue")
queue.async { /* block1 */ }
queue.sync { /* block2 */ } // sync is a fair lock 😊
queue.async { /* block3 */ }

37. DISPATCHQUEUE
27
Synchronous
queue Block1 Block2 Block3
let queue = DispatchQueue(label: "serial-queue")
queue.async { /* block1 */ }
queue.sync { /* block2 */ } // sync is a fair lock 😊
queue.async { /* block3 */ }
Block2

38. DISPATCHQUEUE
27
Synchronous
queue Block1 Block2 Block3
let queue = DispatchQueue(label: "serial-queue")
queue.async { /* block1 */ }
queue.sync { /* block2 */ } // sync is a fair lock 😊
queue.async { /* block3 */ }
Block2

39. DISPATCHQUEUE
27
Synchronous
queue Block2 Block3
let queue = DispatchQueue(label: "serial-queue")
queue.async { /* block1 */ }
queue.sync { /* block2 */ } // sync is a fair lock 😊
queue.async { /* block3 */ }
Block2

40. DISPATCHQUEUE
27
Synchronous
queue
Block2 Block3
let queue = DispatchQueue(label: "serial-queue")
queue.async { /* block1 */ }
queue.sync { /* block2 */ } // sync is a fair lock 😊
queue.async { /* block3 */ }
Block2

41. DISPATCHQUEUE
27
Synchronous
queue
Block3
let queue = DispatchQueue(label: "serial-queue")
queue.async { /* block1 */ }
queue.sync { /* block2 */ } // sync is a fair lock 😊
queue.async { /* block3 */ }

42. DISPATCHQUEUE
27
Synchronous
queue Block3
let queue = DispatchQueue(label: "serial-queue")
queue.async { /* block1 */ }
queue.sync { /* block2 */ } // sync is a fair lock 😊
queue.async { /* block3 */ }

43. DISPATCHQUEUE
27
Synchronous
queue
let queue = DispatchQueue(label: "serial-queue")
queue.async { /* block1 */ }
queue.sync { /* block2 */ } // sync is a fair lock 😊
queue.async { /* block3 */ }

44. DISPATCHQUEUE
28
Target Queue Hierarchy
queue1 1
queue2
1 A 2 B 3 C
2 3
A B C

45. DISPATCHQUEUE
29
Target Queue Hierarchy
queue1
queue2
let queue0 = DispatchQueue(label: "queue0")
let queue1 = DispatchQueue(label: "queue1", target: queue0)
let queue2 = DispatchQueue(label: "queue2", target: queue0)
queue0
3
C
2
BA
1

46. DISPATCHQUEUE
29
Target Queue Hierarchy
queue1
queue2
let queue0 = DispatchQueue(label: "queue0")
let queue1 = DispatchQueue(label: "queue1", target: queue0)
let queue2 = DispatchQueue(label: "queue2", target: queue0)
queue0 3C2BA1

47. DISPATCHQUEUE
30
Target Queue Hierarchy
let queue0 = DispatchQueue(label: "queue0")
let queue1 = DispatchQueue(label: "queue1", target: queue0)
let queue2 = DispatchQueue(label: "queue2", target: queue0)
queue0 BA1 3C2
1 A B 2 C 3

48. DISPATCHQUEUE
Recurring problems
31
• Frequently block threads for resource access
• Many context switch between independent operations

49. 04 FUTURE & PROMISE

50. FUTURE & PROMISE
FUTURE
Wrap a value that may not exist yet
Read-Only
PROMISE
Provide an associated future
Read-Write(Once)
33

51. FUTURE & PROMISE
Example
34
let promise = Promise<Int>()
let future = promise.future

52. FUTURE & PROMISE
Example
35
let promise = Promise<Int>()
let future = promise.future
queue1.async {
future.then { i in /* success */ }
.catch { error in /* failure */ }
}

53. FUTURE & PROMISE
Example
36
let promise = Promise<Int>()
let future = promise.future
queue1.async {
future.then { i in /* success */ }
.catch { error in /* failure */ }
}
queue2.async {
promise.resolve { 1 }
}

54. FUTURE & PROMISE
Example
37
service.call(request: "…") { result in
switch result {
case let .success(data):
service.call(request: "…") { result in
switch result {…}
/* finally do something */
}
case let .failure(error): /* failure */
}
/* finally do something */
}

55. FUTURE & PROMISE
Example
38
service.call(request: "…") { result in
switch result {
case let .success(data):
service.call(request: "…") { result in
switch result {…}
/* finally do something */
}
case let .failure(error): /* failure */
}
/* finally do something */
}
• Is the first completion on the same Thread
that the first service.call ?
• Is the second service.call on the same Thread
that the first completion ?
• Is the second completion on the same Thread
that the second service.call ?

56. FUTURE & PROMISE
Example
39
service.call(request: "…")
.then(qos: .utility) { data in service.call(request: "…") }
.then(qos: .userInteractive) { data in /* success */ }
.catch(qos: .userInteractive) { error in /* failure */ }
.finally(qos: .background) { /* do something */ }

57. FUTURE & PROMISE
Example
40
service.call(request: "…")
.then(qos: .utility) { data in service.call(request: "…") }
.then(qos: .userInteractive) { data in /* success */ }
.catch(qos: .userInteractive) { error in /* failure */ }
.finally(qos: .background) { /* do something */ }
internalQueue thencallthen finallycatch

58. POD IN PROGRESS
41
https://cocoapods.org/pods/AsynchronousSwift