Seer interactive is a digital marketing agency with offices in philadelphia and san diego

SEER Interactive

seerinteractive

In order for your iPhone to remain responsive even when a large amount of data is being downloaded or a call to an external interface is made in the background, iOS applications use a technique called multithreading. Apple provides two multithreading methods for iOS development, Grand Central Dispatch (GCD) and NSOperation. In this article, we will learn about NSOperation. If you need a refresher on the basics of multithreading and concurrency in iOS development, check out . I also recommend before diving into NSOperation. this article learning about GCD NSOperation provides some benefits that GCD does not, such as a more user-friendly interface for dependencies, the Observable property as well as the ability to pause, cancel and resume operations and to specify the number of tasks that can be executed concurrently. Differences between NSOperation and GCD NSOperation has been available since iOS 2. Both NSOperation and GCD encapsulate units of work and dispatch them to a queue for execution. Because these APIs have the same goal, developers are often confused about which one they should utilize for which use case. When Apple introduced GCD, NSOperation was refactored to work on top of GCD. The NSOperation API is a high-level abstraction of GCD, meaning that if you are using NSOperation, you are using GCD below the surface. GCD is a low-level C API that interacts directly with the Unix level of the system. NSOperation is an Objective-C API, which introduces some overhead. Before an instance of NSOperation can be used, it needs to be allocated and then deallocated when it is not needed anymore. This process is optimized but slower than GCD. NSOperation NSOperation is an abstract class that offers a thread-safe structure for modeling state, priority, dependencies, and management. It is part of the Foundation framework and can be used to encapsulate work that should be performed as part of an iOS application’s logic. Developers can build custom subclasses of NSOperation, however, this is not always necessary. Foundation provides the concrete implementations NSBlockOperation and NSInvocationOperation. NSBlockOperation manages the concurrent execution of one or more blocks of code. It can execute several blocks at once without needing to create separate operations for each of them. When more than one block is executed, the operation is considered finished once the execution of all blocks has been completed. NSInvocationOperation manages the execution of a single, non-concurrent encapsulated task. It is used to initiate an operation that invokes a selector on a specified object. In many cases, utilizing one of these predefined implementations will suffice. NSOperationQueue NSOperation is designed to be used in conjunction with NSOperationQueue, a class that manages a queue of NSOperation objects. When adding an NSOperation to an NSOperationQueue, the queue takes care of starting the operation once it is ready and keeping track of its progress. NSOperationQueue manages the concurrent execution of tasks. It functions as a priority queue that roughly follows the FIFO (first in, first out) algorithm, but also considers the priority of a task if it is given. Similarly to Grand Central Dispatch, NSOperation may additionally use the Quality of Service (QOS) classification to describe the urgency of a task. The values and are defined in NSQualityOfService. userInteractive, userInitiated, utility, background // Create a queue
let queue = NSOperationQueue()

// Create operations
let operation1 = NSBlockOperation {    
    print("Performing task 1...")
}

let operation2 = NSBlockOperation {    
    print("Performing task 2...")
}

// Set the priority and quality of service
operation1.queuePriority = .high
operation1.qualityOfService = .userInteractive

operation2.queuePriority = .low
operation2.qualityOfService = .background

// Add the operations to the queue
queue.addOperations([operation1, operation2], waitUntilFinished: false) In this example, an NSOperationQueue is created and two NSBlockOperations are added to it. Multiple operations can be added to the queue at once using the addOperations method. The parameter determines whether the queue should wait for the operations to finish before returning control to the caller. waitUntilFinished An NSOperation can be started using the start() method, but since many of the benefits of NSOperation come from utilizing NSOperationQueue, it is preferable to add a task to a queue like in the given code example rather than stating it directly. Control The behavior of the NSOperationQueue can be customized by setting its maxConcurrentOperationCount property. This property determines the maximum number of operations that can be executed concurrently. If it is set to 1, the queue will execute one operation at a time. If it is set to a higher value, the queue will execute multiple operations concurrently. Observable The NSOperation and NSOperationQueue classes have properties that can be observed using KVO. KVO stands for Key-Value Observing and is a pattern used to notify objects about changes to the properties of other objects. When an operation is ready for execution, it sends a KVO notification for the keypath whose corresponding property then returns true. Each property is mutually exclusive from one another. ready The possible states are: Ready: true if the operation is ready to execute, false if some initialization steps still need to be taken Executing: true if the operation is currently executing, otherwise false Finished: true if the task was finished successfully or if it was canceled An NSOperationQueue does not dequeue any tasks until the finished state returns true. Pause, Resume, Cancel An NSOperation can be paused, resumed, and canceled with the methods pause(), resume() and cancel(). Once a task is dispatched using GCD, you no longer have any control or insight into the execution of that task. The NSOperation API gives the developer control over the operation’s lifecycle. For instance, if it is no longer necessary to carry out a task because it was canceled by the user, NSOperation allows for this cancellation and communicates it through KVO. Dependencies NSOperation provides support for dependencies. This allows developers to execute tasks in a specific order. An operation is ready once every dependency has finished its execution. For instance, if an image should be downloaded and then resized, it is sensible to split these operations up. This way, the downloading operation can be reused to download other data and the resizing operation can be reused for other images that are already available in the cache. Since an image cannot be resized before it is downloaded, the downloading operation is a dependency of the resizing operation. let downloadOperation: NSOperation = ...
let resizeOperation: NSOperation = ...
resizeOperation.addDependency(downloadOperation)
let operationQueue = NSOperationQueue.mainQueue()
operationQueue.addOperations([downloadOperation, resizeOperation], waitUntilFinished: false) A task will not start until all of its dependencies return true for the property. It is important to not create any cycles where two or more tasks depend on each other as this will create a deadlock. finished Completion Block When an NSOperation is finished, it executes its completion block once. This way, the behavior of an operation can be customized. For instance, the completion block of a network operation could do something with the response data from the server once the loading is finalized. let operation = NSOperation()

operation.completionBlock = {    
   print("Finished")    
   // do other things...
}

NSOperationQueue.mainQueue().addOperation(operation) Conclusion The NSOperation API provides an object-oriented model for encapsulating data around structured and repeatable tasks which gives the developer a lot of flexibility. An NSOperation can be scheduled with dependencies and with a particular priority and quality of service. Unlike a block scheduled on a GCD dispatch queue, an NSOperation can be canceled and its state can be queried. Through subclassing, the result of an NSOperation can be associated with itself for future reference. It is important not to add too many operations in a short timeframe as this can lead to performance problems due to NSOperation’s overhead. Apple generally recommends that developers use the highest level of abstraction available. This is because, with every release, the frameworks which power the iOS operating system are optimized. When lower-level APIs are improved, higher-level APIs built on top of them improve as well. According to this philosophy, NSOperation should be used instead of GCD. However, there are cases where GCD is a better fit. GCD should be used for trivial tasks such as dispatching a block of code to a serial or a concurrent queue, speeding up an existing method, or some one-off computation. For these kinds of scenarios, it is not necessary to create an NSOperation subclass and it is generally more convenient to use a lightweight GCD dispatch queue. Therefore a combination of both frameworks is ideal for most projects. The lead image for this article was generated by HackerNoon's AI Image Generator via the prompt "iOS development".

A Guide to NSOperation and NSOperationQueue in iOS Development

Introduction: What is Grand Central Dispatch (GCD) According to Apple:“GCD provides and manages FIFO queues to which your application can submit tasks in the form of block objects. Work submitted to dispatch queues are executed on a pool of threads fully managed by the system. No guarantee is made as to the thread on which a task executes.” In other words, GCD is an API provided by apple to allow you to manage concurrent operations in a smooth way, in order to avoid freezing of your application and keep it always responsive for users. Types of Queues: When dealing with GCD, there are 3 types of queues: 1- The Main Queue: This Queue has the highest priority of all , and it runs on the main thread.All UI updates should be done on this thread or otherwise lagging and weird crashes will occur in your application.You use it simply like this: 2- The Global Queue: This Queue is separated into 4 main types and a default type according to QOS(Quality of Service), from highest priority to lowest: 1- userInteractive : _Work is virtually instantaneous. Similar to main thread._2- userInitiated : Work nearly instantaneous, such a few seconds or less. : don’t use it usually , the type will be inferred by the system4- utility: Work takes a few seconds to a few minutes.5- background: Work takes significant time, such minutes or hours. is as 3- default as Both, utility and background threads should be used for heavy operations that needs time in order not to block the main thread.You can simply call one as follows: 3- Custom Queues: Custom queues are queues that you can create on your own and give whatever QOS and attributes you want: Using Queues Together: Usually in a real world scenario you often need to use those queues together.Let us say you need to do a heavy operation like downloading and image and then display this image in an imageView. You do it as follows: As you can notice we do the heavy operation that can take a lot of time inside a background thread and then display the image inside an imageView using the main thread. Async VS Sync: As you saw in the example above we used the word async after each queue.With GCD, you can dispatch a task either synchronously or asynchronously.Sync means that no other task will start until the sync operation finishes , while Async will allow other tasks to start even if it didn’t finish yet. Let us take a look at real world examples: The Emojis are used to help distinguish between each thread. Notice in the above example both tasks are async , they were executed at the same time. However the userInteractive thread had more priority of execution than the background thread which is normal as discussed before.Now let us take a look if the first task was sync what will happen: As you can see although the userInteractive thread has higher priority it wasn’t executed at all until the first sync task was completed. Even though the above example is simple, it clearly shows how a program behaves with queues running synchronously and asynchronously , so you should be aware of using sync unless needed , and use async in most of the cases to avoid blocking your application in front of your user. Conclusion: There are a lot more to know about managing threads in your application to be fit in a single article . But what is important as a beginner to know that not also you should perform slow or expensive processes on asynchronously , you should always perform them on low priority threads ( example: background thread), and always keep in mind to do any UI updates on the main thread. Some Great References about GCD: Tutorials on Threading. Ray Wenderlich article about concurrency. Appcoda And of course .. . Apple Documentation If you are interested , read my article about Memory management in swift: _In Swift Automatic Reference Counting (ARC) is used to manage memory usage in an iOS application.Each time you create…_medium.com Swift: Avoiding Memory Leaks by Examples

Stories, News & Mentions about SEERINTERACTIVE

Seerinteractive’s Stories on HackerNoon