Parallele Programmierung (German!)

Transcript

1. Macoun ⌘
2. Parallele Programmierung Florian Kugler
3. Ablauf •APIs zur parallelen Programmierung •Einfache Beispiele für Nebenläufigkeit •Zeichnen im Hintergrund •Core Data im Hintergrund •Komplexität von Nebenläufigkeit
4. APIs zur parallelen Programmierung
5. APIs •NSRunLoop •pthread •NSThread •libdispatch •NSOperationQueue
6. NSRunLoop •Keine echte Nebenläufigkeit •Geeignet zur asynchronen Ausführung von Code in einem Thread •-[NSObject performSelector:withObject:afterDelay:] •+[NSTimer scheduledTimerWithTimeInterval: target: selector: userInfo: repeats:] •NSURLConnection
7. NSThread / pthread •Die alte Art der parallelen Programmierung •Benutzt NSOperationQueue oder libdispatch
8. libdispatch •Grand Central Dispatch •C API •Sehr mächtige API, aber auch leicht zu missbrauchen
9. libdispatch •serial queues / concurrent queues / target queue •dispatch_sync / dispatch_async •dispatch_group_async / disaptch_group_notify •dispatch sources •dispatch I/O
10. libdispatch dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); dispatch_async(queue, ^{ // do something ... });
11. libdispatch dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); dispatch_async(queue, ^{ NSData *result = [NSData dataWithContentsOfURL:someURL]; dispatch_async(dispatch_get_main_queue(), ^{ self.imageView.image = [UIImage imageWithData:result]; }); });
12. libdispatch dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); dispatch_async(queue, ^{ NSData *result = [NSData dataWithContentsOfURL:someURL]; dispatch_async(dispatch_get_main_queue(), ^{ self.imageView.image = [UIImage imageWithData:result]; }); });
13. Serial Queue Serial Queue Serial Queue Main Queue High Priority Queue Default Priority Queue Low Priority Queue Background Priority Queue GCD Thread Pool Main Thread Concurrent Queue Serial Queue Concurrent Queue Threads GCD Queues Custom Queues
14. libdispatch •Vorsicht, low level API! •Benutzt libdispatch nur wenn nötig
15. NSOperationQueue •Objective-C Abstraktion von libdispatch •Zusätzliche Features •Eigene NSOperation Unterklassen •Cancel •Prioritäten •Abhängigkeiten
16. NSOperationQueue [[NSOperationQueue mainQueue] addOperationWithBlock:^{ // do something ... }];
17. NSOperationQueue @interface MyOperation : NSOperation @end MyOperation *myOperation = [[MyOperation alloc] init]; [[NSOperationQueue mainQueue] addOperation:myOperation];
18. Einfache Beispiele für Nebenläufigkeit
19. Zeichnen im Hintergrund
20. Zeichnen im Hintergrund •UIKit is nicht thread-safe •Aber wir können im Hintergrund mit Core Graphics zeichnen und dem Main Thread ein UIImage zurückgeben
21. Demo
22. Core Data im Hintergrund
23. Core Data Stack Persistent Store Coordinator Managed Object Context Persistent Store SQLite
24. Zwei Contexte Persistent Store Coordinator Main Context Persistent Store SQLite Hintergrund Context
25. Demo
26. Core Data im Hintergrund •NSManagedObjects sind an den Kontext und Thread gebunden, in dem sie initialisiert wurden •Nebenläufige Contexte können zu Konflikten führen •Merge Policy
27. Zwei Contexte Persistent Store Coordinator Main Context Persistent Store SQLite Hintergrund Context
28. Zwei Coordinators Persistent Store Coordinator Main Context Persistent Store SQLite Hintergrund Context Persistent Store Coordinator Persistent Store
29. Komplexität von Nebenläufigkeit
30. Geteilte Resourcen •Grundproblem der parallelen Programmierung: Geteilte Resourcen •Speicher •Datei •Netzwerkadapter •...
31. Race Condition Thread A Thread B Integer 17 lesen 17 lesen 17 Zeit 17 + 1 = 18 erhöhen 17 + 1 = 18 erhöhen schreiben 18 schreiben 18 Thread A Thread B Integer 17 lesen 17 lesen 17 Zeit 17 + 1 = 18 erhöhen 17 + 1 = 18 erhöhen schreiben 18 schreiben 18
32. Locking •Nur ein Task darf gleichzeitig auf eine Resource zugreifen •Alle anderen müssen warten •Einfachste Beispiele in Objective-C: •@property (atomic, ...) ... •@synchronized() {}
33. Locking Thread A Thread B Integer 17 17 Zeit 17 + 1 = 18 erhöhen schreiben 18 Lock lesen lock unlock 18 18 + 1 = 19 erhöhen schreiben 19 lesen lock unlock Thread A Thread B Integer 17 17 Zeit 17 + 1 = 18 erhöhen schreiben 18 Lock lesen lock unlock 18 18 + 1 = 19 erhöhen schreiben 19 lesen lock unlock
34. Locking •Es gibt viele verschiedene Lock-Varianten mit unterschiedlicher Performance-Charakteristik •Locking kann Performance-Probleme verursachen (Lock Contention)
35. Dead Locks •Mehrere Tasks, die auf die selben Resourcen zugreifen, können sich gegenseitig blockieren
36. Dead Locks Thread 1 Thread 2 Zeit lock Versuch Lock Y lock lock lock Versuch Lock X Thread 1 Thread 2 Zeit lock Versuch Lock Y lock lock lock Versuch Lock X
37. Starvation •Tasks, die ein Schreib-Lock brauchen, kommen nicht zum Zug •Tasks, die nur ein Lese-Lock brauchen, blockieren Schreib-Tasks
38. Priority Inversion •Mars Rover Pathfinder scheiterte beinahe an einem Priority Inversion Bug •Konstellation, in der ein Task niedrigerer Priorität Tasks mit höherer Priorität blockiert •objc.io/issue-2/concurrency-apis-and-pitfalls.html •Relevant für Objective-C Programmierer, denn libdispatch bietet Queues mit verschiedenen Prioritäten an
39. Priority Inversion •DISPATCH_QUEUE_PRIORITY_HIGH •DISPATCH_QUEUE_PRIORITY_DEFAULT •DISPATCH_QUEUE_PRIORITY_LOW •DISPATCH_QUEUE_PRIORITY_BACKGROUND
40. Komplexität •Nebenläufigkeit hat viele schwierige Probleme •Benutzt den Main-Thread wenn möglich •Haltet nebenläufigen Code so einfach wie möglich
41. Fragen?
42. Vielen Dank @floriankugler mail@floriankugler.com www.objc.io