Core Data is designed to work in a multithreaded environment. However, not every object under the Core Data framework is thread-safe. To use Core Data in a multithreaded environment, ensure that:
- Managed object contexts are bound to the thread (queue) that they are associated with upon initialization.
- Managed objects retrieved from a context are bound to the same queue that the context is bound to.
Concurrency is the ability to work with the data on more than one queue at the same time. The work submitted to these queues is executed on a thread.
Core Data, Multithreading, and the Main Thread
In Core Data, the managed object context which is the heart of the Core Data stack can be used with two concurrency patterns, defined by NSMainQueueConcurrencyType and NSPrivateQueueConcurrencyType.
NSMainQueueConcurrencyType
is specifically for use with your application interface and can only be used on the main queue of an application which always run on main thread. As said it can only be used in your application interface (UI) related work. Avoid doing data processing on this. , Like importing data into Core Data from JSON
NSPrivateQueueConcurrencyType
configuration creates its own queue upon initialization and can be used only on that queue. Because the queue is private and internal to the NSManagedObjectContext instance, it can only be accessed through the performBlock: and the performBlockAndWait: methods. We will look this in depth when we will be doing coding part.
Using a Private Queue to Support Concurrency
In general, avoid doing data processing on the main queue that is not user-related. Data processing can be CPU-intensive, and if it is performed on the main queue, it can result in unresponsiveness in the user interface. If your application will be processing data, such as importing data into Core Data from JSON, create a private queue context and perform the import on the private context. The following example shows how to do this:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
let jsonArray = … //JSON data to be imported into Core Data let moc = … //Our primary context on the main queue let privateMOC = NSManagedObjectContext(concurrencyType: .PrivateQueueConcurrencyType) privateMOC.parentContext = moc privateMOC.performBlock { for jsonObject in jsonArray { let mo = … //Managed object that matches the incoming JSON structure //update MO with data from the dictionary } do { try privateMOC.save() moc.performBlockAndWait { do { try moc.save() } catch { fatalError("Failure to save context: \(error)") } } } catch { fatalError("Failure to save context: \(error)") } } |
In this example, an array of data has been originally received as a JSON payload. You then create a new NSManagedObjectContext that is defined as a private queue. The new context is set as a child of the main queue context that runs the application. From there you call performBlock: and do the actual NSManagedObject creation inside of the block that is passed to performBlock:. After all of the data has been consumed and turned into NSManagedObject instances, you call save on the private context, which moves all of the changes into the main queue context without blocking the main queue.
Conclusion
So pls follow the above step and And if you have any issue or suggestion you can leave your message in the comment section I will try to solve this.