#nsoperationqueue

Swift – BlockOperation 사용하기

Operation(NSOperation)은 특정한 작업을 수행하기 위한 코드와 데이터를 감싸는 객체로 해당 작업을 동기/비동기로 필요한 시점에 실행하기 위한 용도로 사용한다. NSOperation은 OSX 10.5에서도입되었는데, 이 시점의 Objective-C에서는 클래스의 외부에서 코드를 주입할 수 있는 언어적인 장치가 존재하지 않았기 때문에, 이를 사용하려면 무조건 NSOperation의 서브클래스를 만들어야 하는 불편한 점이 있었다. 따라서 간단한 코드 조각을 실행하기 위해서 NSOperation을 사용하는 것은 꽤나 불편한 일이었다.

OSX 10.6(스노우레퍼드)부터 GCC/Clang을 기본 컴파일러로 사용하게 되었고 이때부터 코드블럭 기능이 지원되었다. 즉 별도의 서브클래스를 작성하지…

original source : https://agostini.tech/2017/07/30/understanding-operation-and-operationqueue-in-swift/#comment-141

There are more ways than one to do concurrent operations on iOS. In this article, we’ll cover how to use Operations and OperationQueue to execute concurrent operations. There’s a lot to be said (and written) about concurrency on iOS and I don’t really want to bore you to death by writing a massive article about it, so I’ll focus here on Operations because chances are these will cover most of your needs for concurrent operations. We’ll touch a bit on GCD because sometimes you just need to dig in deep and do it yourself.

Concurrency

This is just a fancy way of saying ‘doing stuff at the same time’. The iPhone is capable of executing multiple threads at the same time. I could go into the nitty gritty details about threads and queues, but you don’t really care about them. You just want to use your OperationQueue… Fair enough

Just remember one thing – on your iOS device you’ll see two types of queues; the main queue, and everything else. In your day-to-day development, you can split all of your operations as being run on the main queue or off the main queue. Clearly, the main queue is important… So what is it exactly? Well, it’s where your UI gets updated. All the user interactions and all the animations get executed on the main queue. You don’t really want to run your code on the main queue because you’ll be blocking the UI and the user will see the UI as being unresponsive so they might even kill your app.

The Queues

All your UI updates should be performed on the main queue and you should do as much work as possible in the background, which is sometimes referred to as ‘off the main queue’. You want to keep the main queue clear.

The main queue is like a priority boarding queue at an airport. Some people buy priority boarding but most don’t and the people in the priority boarding queue board the plane before the people in the other queue (at least that’s how Ryanair does it ) Imagine what would happen if everyone bought a priority boarding pass. That queue would be full and the other queue would be empty so the priority queue would lose its purpose. The priority queue, just like the main queue, works only if you use it sparingly. There can be only one main queue and you can have as many background queues as you want.

The most common example would be refreshing a table view. You pull to refresh, start animating the spinner, kick off your networking request in the background and then when you’re finished processing and parsing the response you reload the table on the main queue.

Let’s use this example to demonstrate the usage of Operations and OperationQueue. I’ll use one of my projects on GitHub – DADependencyInjection – to demonstrate this.

Operation

Operation is an abstract class and represents a logical unit of work. For example, in your code you probably have a method that fetches data from the API. If you want to use OperationQueue you would have to create your class that subclasses Operation and move that method in your new class. Doing this has an added benefit of forcing you to use the single responsibility principle.

Once you have your class you add it to your OperationQueue and wait for it to finish executing. If you just want to execute a small piece of code or call a method you can use BlockOperation and NSInvocationOperation instead of subclassing Operation.

In our example we’ll use two operations, but first, we’ll create a base class for our operations just to get some of the clutter out of the way:

class DAOperation: Operation {

   private var _executing = false {        willSet {            willChangeValue(forKey: "isExecuting")        }        didSet {            didChangeValue(forKey: "isExecuting")        }    }

   override var isExecuting: Bool {        return _executing    }

   private var _finished = false {        willSet {            willChangeValue(forKey: "isFinished")        }

       didSet {            didChangeValue(forKey: "isFinished")        }    }

   override var isFinished: Bool {        return _finished    }

   func executing(_ executing: Bool) {        _executing = executing    }

   func finish(_ finished: Bool) {        _finished = finished    } }

We’ll create two operations: one for networking and one for parsing. Our networking operation will look like this:

class GetDataOperation: DAOperation {

   private let urlString: String    private let provider: NetworkingProvider

   var responseData: Data?

   init(withURLString urlString: String, andNetworkingProvider provider: NetworkingProvider = AFNetworkConnector()) {        self.urlString = urlString        self.provider = provider    }

   override func main() {        guard isCancelled == false else {            finish(true)            return        }

       executing(true)        provider.restCall(urlString: urlString) { (data) in            self.responseData = data            self.executing(false)            self.finish(true)        }    } }

We’re initializing this class with a URL string and a networking provider. We’re exposing a ‘responseData’ property where we’ll save the networking response. This class is nothing more than a wrapper around our networking provider. Parse operation is even simpler:

Parse operation is even simpler:

class ParseDataOperation: DAOperation {

   private let factory: MoviesFactoryProvider

   var moviesData: Data?    var movies: [MovieItem]?

   init(withFactory factory: MoviesFactoryProvider = MoviesFactory()) {        self.factory = factory    }

   override func main() {        guard isCancelled == false else {            finish(true)            return        }

       executing(true)        guard            let data = moviesData,            let jsonObject = try? JSONSerialization.jsonObject(with: data, options: [JSONSerialization.ReadingOptions.allowFragments])            else {                executing(false)                finish(true)                return        }

       movies = factory.movieItems(withJSON: jsonObject)

       executing(false)        finish(true)    } }

We have two important properties at the top: ‘moviesData’ and ‘movies’. Networking operation will set the ‘moviesData’ property. We’ll feed this data into our factory and save the movies array into the instance variable ‘movies’.

When you start your operation the main method gets called. This method will be called by the OperationQueue automatically so all you have to do is add your operations to the queue.

OperationQueue

You create your OperationQueue and start adding your operations to it. OperationQueue is a prioritised FIFO queue which means you can set priority on individual operations. Those with the highest priority get pushed ahead, but not necessarily to the front of the queue, as iOS determines when to actually execute the operation. Operations with the same priority get executed in the order they were added to the queue unless an operation has dependencies.

You can set the priority of your operations by setting your queuePriority property of the operation. You can also control how much of the system resources will be given to your operation by setting qualityOfService property. OperationQueue can execute multiple operations at the same time. You can set the number of maxConcurrentOperationCount or you can let the system set this property to the default value which is different for each device.

A beautiful thing about operations is that they can be cancelled which is something you can’t do with blocks. Let’s say you have three operations: networking call, parsing of data and saving in the database. If your networking call fails, there’s little sense in executing the remaining two operations so you can simply cancel them.

In our example we’ll create a new data provider for movies. We’ll create a new property, ‘operationQueue’, and initialize it to the OperationQueue:

private let operationQueue: OperationQueue = OperationQueue()

Now all we need to do is create our operations and add them to the queue:

let networkingOperation = GetDataOperation(withURLString: urlString, andNetworkingProvider: networkingProvider) let parsingOperation = ParseDataOperation(withFactory: moviesFactory)

operationQueue.addOperations([networkingOperation, parsingOperation], waitUntilFinished: false)

As soon as you add your operations to the queue they will start executing. As I said before the main method will get called for each operation when it starts executing.

Dependencies

In some cases your operations might depend on other operations to finish.

Your ParseDataOperation depends on the successful completion of the GetDataOperation. If your operation has dependencies it will not start until they all finish. This little feature is really powerful if you’re dealing with complex logic because it greatly simplifies your code.

Let’s go over this example for dependencies:

networkingOperation.completionBlock = {   parsingOperation.moviesData = networkingOperation.responseData }

parsingOperation.completionBlock = {   onCompleted?(parsingOperation.movies ?? []) } parsingOperation.addDependency(networkingOperation)

We have our two operations again: parsingOperation and networkingOperation, but this time parsingOperation has a dependency set to networkingOperation. So parsingOperation will never start before networkingOperation.

Every operation has a ‘completionBlock’ that gets called when the operation finishes. We’ll use these completion blocks to pass data between operations. When the networking operation completes it sets the ‘moviesData’ property on the parsing operation. And when the parsing operation completes it calls the closure and passes in the movies.

At the end of the code listing, we’re setting our dependency.

What About GCD?

GCD stands for Grand Central Dispatch. You might think that with OperationQueues and Operations there’s no need for GCD but they actually work together. Fun fact: Operations are built on top of GCD.

I primarily use GCD to dispatch my closures back on the main thread. We talked a lot about Operations and OperationQueues here, but sooner or later you will have to update your UI to reflect the state of your app. UI updates must happen on the main thread so you need a way to dispatch code back to the main thread. One of the easiest ways to do that is to use GCD.

GCD is great if you need to use advanced things like semaphores and barriers. I won’t go into details on how to use them here but you can see an example of using barriers in my article on Singletons in Swift.

The most common use of GCD is to run a piece of code on the main thread – like the ‘onCompleted’ closure in our example here:

DispatchQueue.main.async(execute: {   onCompleted?(listItems) })

Conclusion

OperationQueue is a great tool to use if you have complex logic in your app and if you have to manage dependencies between the operations. It’s very elegant at that. Passing data between operations is a bit messy. When your operation is finished you store the data in an instance variable which you read from the dependent operation. That’s not very elegant at all. There are much neater solutions out there like, for example, PromiseKit, which I’ll cover in one of the next articles.

I hope I gave you enough of an intro into Operations so you can use them in your apps where appropriate. You can find all the example code in my GitHub repo.

Have a nice day

original source : https://cocoacasts.com/choosing-between-nsoperation-and-grand-central-dispatch/

While NSOperation and NSOperationQueue have been available since iOS 2, Grand Central Dispatch, GCD for short, was introduced in iOS 4 and OS X 10.6 Snow Leopard. Both technologies are designed to encapsulate units of work and dispatch them for execution. Because these APIs serve the same goal, developers are often confused when to use which.

Before I answer the questions when to use which API, I would like to discuss the key difference between NSOperation and Grand Central Dispatch.

What Sets Them Apart

Comparing NSOperation and Grand Central Dispatch is comparing apples and oranges. Why is that? With the introduction of Grand Central Dispatch, Apple refactored NSOperation to work on top of Grand Central Dispatch. The NSOperation API is a higher level abstraction of Grand Central Dispatch. If you are using NSOperation, then you are implicitly using Grand Central Dispatch.

Grand Central Dispatch is a low-level C API that interacts directly with Unix level of the system. NSOperation is an Objective-C API and that brings some overhead with it. Instances of NSOperation need to be allocated before they can be used and deallocated when they are no longer needed. Even though this is a highly optimized process, it is inherently slower than Grand Central Dispatch, which operates at a lower level.

Benefits of NSOperation

Since NSOperation is built on top of Grand Central Dispatch, you may be wondering what NSOperation offers that Grand Central Dispatch doesn't. There are several compelling benefits that make NSOperation an interesting choice for a number of use cases.

Dependencies

The NSOperation API provides support for dependencies. This is a powerful concept that enables developers to execute tasks in a specific order. An operation is ready when every dependency has finished executing.

Observable

The NSOperation and NSOperationQueue classes have a number of properties that can be observed, using KVO (Key Value Observing). This is another important benefit if you want to monitor the state of an operation or operation queue.

Pause, Cancel, Resume

Operations can be paused, resumed, and cancelled. Once you dispatch a task using Grand Central Dispatch, you no longer have control or insight into the execution of that task. The NSOperation API is more flexible in that respect, giving the developer control over the operation's life cycle.

Control

The NSOperationQueue also adds a number of benefits to the mix. For example, you can specify the maximum number of queued operations that can run simultaneously. This makes it easy to control how many operations run at the same time or to create a serial operation queue.

When to Use Which

In general, Apple advises developers to use the highest level of abstraction that is available. If we apply this advice, then the NSOperation API should be your first choice.

But why does Apple advise developers to use the highest level of abstraction? With every release, Apple tweaks and optimizes the frameworks and libraries that power the operating system. This usually involves changes affecting low(er)-level APIs. Even though APIs built on top of these low-level APIs change less frequently, they still benefit from the improvements Apple makes to the APIs they are built on.

Great. But when do you use which technology? Should you avoid Grand Central Dispatch only because it is a low-level API? You can use Grand Central Dispatch whenever and wherever you like. Many developers swear by Grand Central Dispatch, but most developers use a combination NSOperation and Grand Central Dispatch.

When to Use

NSOperation

The NSOperation API is great for encapsulating well-defined blocks of functionality. You could, for example, use an NSOperation subclass to encapsulate the login sequence of an application.

Dependency management is the icing on the cake. An operation can have dependencies to other operations and that is a powerful feature Grand Central Dispatch lacks. If you need to perform several tasks in a specific order, then operations are a good solution.

You can go overboard with operations if you are creating dozens of operations in a short timeframe. This can lead to performance problems due to the overhead inherent to the NSOperation API.

When to Use Grand Central Dispatch

Grand Central Dispatch is ideal if you just need to dispatch a block of code to a serial or concurrent queue. If you don't want to go through the hassle of creating an NSOperationsubclass for a trivial task, then Grand Central Dispatch is a great alternative. Another benefit of Grand Central Dispatch is that you can keep related code together. Take a look at the following example.

let dataTask = session.dataTaskWithRequest(request, completionHandler: { (data, response, error) -> Void in    // Process Response    ...    dispatch_async(dispatch_get_main_queue(), { () -> Void in        // Update User Interface        ...    }) })

In the completion handler of the data task, we process the response and update the user interface by dispatching a closure (or block) to the main queue. This is necessary because we don't know which thread the completion handler is executed on and it most likely is a background thread.

This example illustrates how related code is grouped together. It also highlights the elegance of the Grand Central Dispatch syntax. Asynchronously dispatching a task to the main queue requires only a few lines of code.

NSBlockOperation

The NSOperation class should never be used as is. It is meant to be subclassed. Foundation also provides a concrete subclass that is ready to be used, NSBlockOperation. This class combines the best of both worlds, you can use closures and still benefit from the NSOperation API.

let operation = NSBlockOperation(block: { () -> Void in    // Do Something    ... }) operationQueue.addOperation(operation)

Some consider the NSBlockOperation redundant because you might as well use Grand Central Dispatch instead. I don't agree with this view. As the above example illustrates, the NSBlockOperation combines the elegance of closures and the benefits of operations. There is nothing wrong with NSBlockOperation in my opinion.

Conclusion

original source : http://ioscoachfrank.com/2016/12/06/getting-started-with-operations.html

This article is part of a 4-part series on Building robust, reliable code with NSOperations.

Getting Started With NSOperation and NSOperationQueue

Chaining a Series of NSOperations

Grouping Common Operations Together

Handling UI with NSOperations

This article focuses on the basics of Operation and OperationQueue so you can start using them in your own apps. It also lays the groundwork for the cool stuff we’ll be doing in subsequent parts. If you’d like to follow along with a playground, you can find the gist over this way 👉 Operations Part 1

Let’s dive in!

What is an Operation?

At its core, Operation is an abstract class used to model a unit of work. It works in tandem with OperationQueue to create very sophisticated behaviour which would otherwise be incredibly tedious to implement.

In other words, Operations are like blocks of code with superpowers.

What kind of superpowers?

They are reusable within your project, and often between projects.

They are multi-core aware, so you’re always using as many cores as possible on the device.

They know about thread quality of service, so the OS can make intelligent decisions about resource management.

They are priority-aware, meaning you can tell the system what’s important (loading more tweets) vs. what’s not-so-important (downloading user avatars).

They are testable, making your code robust ᕦ(ò_óˇ)ᕤ

Not bad eh?

As for what can you run inside an Operation, well, that’s really up to you. Here are a few examples to whet your appetite:

Fetching data from a web server.

Showing a UIAlertController to the user.

Triggering a segue in a UIStoryboard

Requesting permission for Push Notifications

Excited? Of course you are! Let’s look at how they work.

The life of an Operation

Operations have a well-defined lifecycle that you can hook into. However, it’s not quite implemented in the way you’d expect.

At a high level, the lifecycle looks like this:

These states are controlled by 4 KVO-enabled boolean properties: isReady, isExecuting, isFinished and isCancelled.

Operations start in the Pending state when they are first added to a queue. Nothing really interesting to see here. The 4 flags are all false

At some point, when an Operation becomes ready to execute, it moves to the Ready state. It’s now eligible to be executed by the OperationQueue. isReady now equals true and all the other flags equal false.

(Actually, there’s a little more that goes into Operations becoming Ready, and we’ll talk more about it in part 2 of this series.)

Then the operation moves to the Executing state. This means it’s currently doing its thing (i.e. executing its main() method). isReady and isExecuting equal true and the other 2 flags equal false.

Finally, when it’s done, the operation moves to the Finished state. At this point, isExecutingequals false and isFinished equals true. Do notice, however, that this state provides no indication as to whether or not the operation was successful. This’ll be important to keep in mind for later ☝️

Also, at any point before it’s finished, an Operation can be cancelled. This moves it to the Cancelled state (isCancelled is true).

Cancelling Operations

Cancelling means exactly what you would expect it to: abort whatever you are doing and clean up as soon as possible. You can cancel an Operation by using its cancel() method and you can check if it was cancelled by using its cancelled property.

There’s a catch to this though. Since the meaning of “cancel” can change from operation to operation, it’s up to you to periodically check the isCancelled flag during the execution of your operation in order to stop execution and/or clean up any ongoing tasks. This could amount to cancelling a URLSessionTask, for example.

Operations and Queues

Now that we’ve seen how Operations work, it’s important to take a step back and have a look at our hero’s sidekick: the OperationQueue.

OperationQueues are what we use to run Operations. They take care of all the nitty gritty, like priorities, dependencies, and moving the Operations from state to state.

You can add an Operation to a queue by using the addOperation(_:) method. It looks something like this:

let fetchPokemon = FetchPokemonOperation() let operationQueue = OperationQueue() operationQueue.addOperation(fetchPokemonOp)

Easy right? You just add the operation, sit back, and wait for it to execute.

Much like Operations, OperationQueues have a few interesting properties and methods as well.

Since an OperationQueue will only execute Operations that are in the Ready state, it may choose to execute the 4th operation in the queue if the first 3 are still Pending. Therefore, make sure you don’t confuse this queue with a more traditional FIFO (first in, first out) queue, because you’ll end up being quite surprised 🙃

The isSuspended flag allows you to start and stop an operation queue. In the next article, we’ll see how we can make use of this property for some interesting behavior. By default, queues are not suspended (i.e. isSuspended is false).

maxConcurrentOperationCount allows you to set how many operations you want to execute at once. By default, it’ll run as many as possible. Usually this is fine. By setting this value to 1, you can create a serial queue.

QualityOfService allows you to set the default service level of the threads on which the operation will execute. Service levels dictate the priority with which the Operation will gain access to system resources, such as CPU and disk access. Using the default here will work, but if you want to be a good citizen, you should consider setting this property to what is most appropriate. You can check out the doc here.

Ok, enough about queues. Let’s move onto actually building these things!

Building our first Operation

Building an Operation can be very easy: all you need to do is subclass the Operation class and override the main() method. And let’s not forget to exit early if the Operation has been cancelled 💁‍♂️

An Operation that logs to the console looks something like this:

class LoggingOperation : Operation {    override func main() {        if isCancelled {            return        }                print("Logging operation")    } }

When the Operation becomes ready to execute, the OperationQueue will run its main()method. Once the main() method is completed, the operation’s isFinished flag gets set to true and the operation gets removed from the queue.

However, this can cause issues with long running, asynchronous tasks.

Imagine you create an operation to download data from a server. What do you think will happen once we reach the end of the main() method?

The main() method will complete before the URLSessionTask returns. This means that your operation will no longer exist by the time the data returns from the server.

Not cool.

In order to make sure your operation is still around, we’ll need to take control of its lifecycle. Lucky for us, the documentation is quite robust when it comes to overriding this behavior.

It states that we need to correctly manage the isExecuting flag and the isFinished flag. Here’s what that looks like, KVO notifications and all:

class ConcurrentOperation: Operation {    private var backing_executing : Bool    override var isExecuting : Bool {        get { return backing_executing }        set {            willChangeValue(forKey: "isExecuting")            backing_executing = newValue            didChangeValue(forKey: "isExecuting")        }    }        private var backing_finished : Bool    override var isFinished : Bool {        get { return backing_finished }        set {            willChangeValue(forKey: "isFinished")            backing_finished = newValue            didChangeValue(forKey: "isFinished")        }    }        override init() {        backing_executing = false        backing_finished = false                super.init()    }        func completeOperation() {        isExecuting = false        isFinished = true    } }

willChangeValue :  Informs the observed object(관찰되어지고 있는 obj) that the value of a given property is about to change.

We’ve effectively created a base class for all the concurrent operations we’ll create in the future. It overrides both isExecuting and isFinished, as well as adding a new method called completeOperation(). This is the method we’re going to call in order to tell the rest of the system that our operation is, in fact, finished.

But beware! When using this base class, we’ll need to make sure that all code paths lead to completeOperation(). Otherwise, the operation will never finish, and thus never get removed from the queue.

With this new ConcurrentOperation base class, let’s look at what a download operation would look like:

class FetchPokemonOperation : ConcurrentOperation {    private var task: URLSessionDataTask?    var data: AnyObject?        override func main() {        if isCancelled {    completeOperation()            return        }                let session = URLSession(configuration: .ephemeral)        let request = URLRequest(url: URL.init(string: "http://pokeapi.co/api/v2/pokemon/151/")!)                task = session.dataTask(with: request, completionHandler: { (data, response, error) in            if self.isCancelled {        self.completeOperation()                return            }                        //Be a good citizen and handle errors, ok? :)                        let parsedResponse = try! JSONSerialization.jsonObject(with: data!)            self.data = parsedResponse as AnyObject            print(self.data!)    self.completeOperation()        })                task?.resume()    } }

As you can see, we now subclass ConcurrentOperation as opposed to Operation, and we’ve also added a call to completeOperation() inside the completion block of our data task.

If we try running this, we’ll see that it completes successfully since we’re keeping the operation alive during the duration of its execution.

Great job! 🙃

Where do we go from here?

Let’s recap! Today we took our first look at Operations and OperationQueues. We created Operations and executed them using an OperationQueue. We also looked at how we could hook into their lifecycle to ensure that our concurrent tasks stay alive long enough.

Next week, we’ll see how we can use multiple operations together. Now that we’ve laid the groundwork, we’ll look at how we can chain multiple Operations together in order create complex behavior in a very simple way.

I hope you’ll join me next week!

If you enjoyed the article, you can follow me on Twitter and share it with your friends! If you want to make sure to be notified of part 2 (which is where we really get into the powerful stuff), you can sign up to the email list in the footer below!

NSOperationQueue and GCD both achieve the same thing. Meaning, both are meant to execute tasks concurrently/serially in a multi-threaded model. But they are different in performing this goal. Let’s start with how each of them work and then we’ll get into comparison of when to use which one :)

NSOperationQueue: NSOperations and NSOperationQueue are objective C classes. They are higher level of abstraction classes built on top of GCD.

Controlling the state of Operations: NSOperations can be cancelled, resumed as per our needs

Dependancy: NSOperations enable us to set up dependencies between them so that we can frame the order in which operations are executed. 

Control over number of threads: NSOperationQueue allow us to specify maxNumberOfConcurrent threads that can be invoked at a given time.

Monitoring state of Operations: NSOperationQueue lets us monitor the state of operation - executing, finished, starting and so on.

GCD: It is a low level API which enables very simple task based concurrency model. Its implementation is super simple.

When to use which one:

Apple generally advices us to use NSOperationQueues since they are higher level of abstracted classes that have all the benefits of GCD. Whenever, we have tasks that needs to be monitored closely in the order we want them to run or if we have a need to cancel/resume them at any point we use NSOperationQueues. For example: Read/Write on a shared resource to avoid race conditions. 

We use GCD, whenever, we don’t have to worry about logistics of what or how many tasks are being executed. When we just want to execute some block of code in background and need results from the execution, we use GCD. For Eg: Downloading image/file in background and displaying/using file contents to show them in tableView.

Found a very good Article: https://www.appcoda.com/ios-concurrency/ which gives very detailed explanation of all the little concepts involved in understanding concurrency, GCD and NSOpertionQueues. Simply Loved it!!

Fixed NSOperation vs Grand Central Dispatch #dev #it #asnwer

NSOperation vs Grand Central Dispatch

I’m learning about concurrent programming for iOS. So far I’ve read about NSOperation/NSOperationQueue and GCD. What are the reasons for using NSOperationQueue over GCD and vice versa?

Sounds like both GCD and NSOperationQueue abstract away the explicit creation of NSThreadsfrom the user. However the relationship between the two approaches isn’t clear to me…

How to: NSOperation vs Grand Central Dispatch

NSOperation vs Grand Central Dispatch

I’m learning about concurrent programming for iOS. So far I’ve read about NSOperation/NSOperationQueue and GCD. What are the reasons for using NSOperationQueue over GCD and vice versa?

Sounds like both GCD and NSOperationQueue abstract away the explicit creation of NSThreadsfrom the user. However the relationship between the two approaches isn’t clear to me…