Intro As you may or may not kNow I recently did a talk at the Des Moines Cocoaheads in which I reviewed Blocks and Grand Central dispatch. I have tried to capture the content of that talk and a lot more here in this article. The talk encompassed

• Blocks
• Grand Central dispatch
• GCD Design Patterns
• Cocoa API''s using GCD and Blocks

All of the content of this article applies only to Mac OS X 10.6 SNow Leopard as blocks support and Grand Central dispatch are only available there. There are alternate methods to get blocks onto Mac OS X 10.5 and the iPhone OS via projects likePlausible Blocks which have blocks support,though do not have Grand Central dispatch (libdispatch.)

Grand Central dispatch is Open Source I should mention that Apple has in fact Open Sourced libdispatch (Grand Central Dispatch) on Mac OS Forge and the other components like Kernel Support for GCD (although if implemented on other OS''s this is not necessary) and the blocks runtime support are all freely available and if you want you can even checkout the libdispatch repository using Git with the command git clone git://git.macosforge.org/libdispatch.git

Blocks

Blocks are part of a new C Language Extension,and are available in C,Objective-C,C++ and Objective-C++. Right off the bat,I should say that while we will use blocks with Grand Central dispatch a lot later on,they are not required when using Grand Central dispatch. Blocks are very useful onto themselves even if you never use them with anything else. However we gain a lot of benefit when we use blocks with Grand Central dispatch,so pretty much all my examples here will use blocks.

What are blocks? Well let me show you a very basic example of one

^{ NSLog(@"Inside a block"); }

This is a very basic example of a block,but it is basically a block that accepts no arguments and contains a NSLog() statement. Think of blocks as either a method or snippet of code that accepts arguments and captures lexical scope. Other languages have already had something like this concept implemented for a while (since the 70''s at least if I remember correctly.) Here''s a couple examples of this concept in one of my favorite languages Python

>>>f = lambda x,y,z: x + y + z
...
>>> f(2,3,4)
9

Here we are defining a lambda in Python which is basically a function that we can execute later on. In Python after the lambda keyword you define the arguments that you are passing in to the left of the colon and the right is the actual expression that will get executed. So in the first line of code we''ve defined a lambda that accepts 3 arguments and when it''s invoked all it will do is accept the arguments and add them together,hence when we invoke f like f(2,4) we get 9 back. We can do more with Python lambda''s. Python has functions that actually do more with lambdas like in this example...

>>>reduce((lambda x,y: x+y),[1,2,4])
10
>>>reduce((lambda x,y: x*y),4])
24

This reduce function uses a lambda that accepts 2 arguments to iterate over an array. The lambda in this case accepts 2 arguments (as the reduce function requires) and in the first example just iterates over the array with it. Python begins by calling the lambda using the first 2 elements of the array then gets a resulting value and again calls the lambda with that resulting value and the next element in the array and keeps on calling the lambda until it has fully iterated over the data set. So in other words the function is executed like so (((1 + 2) + 3) + 4)

Blocks bring this concept to C and do a lot more. You might ask yourself "But haven''t we already had this in C? I mean there are C Function Pointers." Well yeah,but while blocks are similar in concept,they do a lot more than C Function Pointers,and even better if you already kNow how to use C function pointers,Blocks should be fairly easy to pick up.

Here is a C Function Pointer Declaration...

 void (*func)(void); 

...and here is a Block Declaration...

 void (^block)(void); 

Both define a function that returns nothing (void) and takes no arguments. The only difference is that we''ve changed the name and swapped out a "*" for a "^". So lets create a basic block

 int (^MyBlock)(int) = ^(int num) { return num * 3; }; 

The block is laid out like so. The first part signifies that it''s a block returning an int. The (^MyBlock)(int) is defining a block of the MyBlock type that accepts an int as an argument. Then the ^(int num) to the right of the assignment operator is the beginning of the block,it means this is a block that accepts an int as an argument (matching the declaration earlier.) Then the { return num * 3; }; is the actual body of the block that will be executed.

When we''ve defined the block as shown earlier we can then assign it to variables and pass it in as arguments like so...

int aNum = MyBlock(3);

printf(“Num %i”,aNum); //9 

Blocks Capturing Scope: When I said earlier that blocks capture lexical scope this is what I mean,blocks are not only useful to use as a replacement for c function pointers,but they also capture the state of any references you use within the block itself. Let me show you...

int spec = 4;
 
int (^MyBlock)(int) = ^(int aNum){
 return aNum * spec;
};

spec = 0;
printf("Block value is %d",MyBlock(4));

Here we''ve done a few things. First I declared an integer and assigned it a value of 4. Then we created the block and assigned it to an actual block implementation and finally called the block in a printf statement. And finally it prints out "Block value is 16"? Wait we changed the spec number to 0 just before we called it didn''t we? Well yes actually we did. But what blocks do actually is create a const copy of anything you reference in the block itself that is not passed in as an argument. So in other words we can change the variable spec to anything we want after assigning the block,but unless we are passing in the variable as an argument the block will always return 16 assuming we are calling it as MyBlock(4). I should also note that we can also use C''s typedef utility to make referencing this type of block easier. So in other words...

int spec = 4;
 
typedef int (^MyBlock)(int);
 
MyBlock InBlock = ^(int aNum){
 return aNum * spec;
};

spec = 0;
printf("InBlock value is %d",InBlock(4));

is exactly equivalent to the prevIoUs code example. The difference being is that the latter is more readable.

__block Blocks do have a new storage attribute that you can affix onto variables. Lets say that in the prevIoUs example we want the block to read in our spec variable by reference so that when we do change the variable spec that our call toInBlock(4) actually returns what we expect it to return which is 0. To do so all we need to change is adding __block to spec like so...

__block int spec = 4;
 
typedef int (^MyBlock)(int);
 
MyBlock InBlock = ^(int aNum){
 return aNum * spec;
};

spec = 0;
printf("InBlock value is %d",245)"> and Now the printf statement finally spits out "InBlock value is 0",because Now it''s reading in the variable spec by reference instead of using the const copy it would otherwise use.
 
 Blocks as Objective-C objects and more! Naturally going through this you''d almost be thinking right Now that blocks are great,but they Could potentially have some problems with Objective-C,not so Blocks are Objective-C objects! They do have a isa pointer and do respond to basic commands like -copy and -release which means we can use them in Objective-C dot Syntax like so...
 
@property(copy) void(^myCallback)(id obj);
@property(readwrite,copy) MyBlock inBlock;
 
 and in your Objective-C code you can call your blocks just like so self.inBlock();.
 
 Finally I should note that while debugging your code there is a new GDB command specifically for calling blocks like so
 
$gdb invoke-block MyBlock 12 //like MyBlock(12)
$gdb invoke-block StringBlock “\” String \”” 
 
 These give you the ability to call your blocks and pass in arguments to them during your debug sessions.
 
 
 
 Grand Central dispatch
 
 Now onto Grand Central dispatch (which I may just reference as GCD from here on out.) Unlike past additions to Mac OS X like say NSOperation/NSThread Subclasses,Grand Central dispatch is not just a new abstraction around what we''ve already been using,it''s an entire new underlying mechanism that makes multithreading easier and makes it easy to be as concurrent as your code can be without worrying about the variables like how much work your cpu cores are doing,how many cpu cores you have and how much threads you should spawn in response. You just use the Grand Central dispatch API''s and it handles the work of doing the appropriate amount of work. This is also not just in Cocoa,anything running on Mac OS X 10.6 SNow Leopard can take advantage of Grand Central dispatch ( libdispatch ) because it''s included in libSystem.dylib and all you need to do is include #import <dispatch/dispatch.h> in your app and you''ll be able to take advantage of Grand Central dispatch.
 
 Grand Central dispatch also has some other nice benefits. I''ve mentioned this before in other talks,but in OS design there are 2 main memory spaces (kernel space and user land.) When code you call executes a syscall and digs down into the kernel you pay a time penalty for doing so. Grand Central dispatch will try and do it''s best with some of it''s API''s and by pass the kernel to return to your application without digging into the kernel which means this is very fast. However if GCD needs to it can go down into the kernel and execute the equivalent system call and return back to your application.
 
 Lastly GCD does some things that threading solutions in Leopard and earlier did not do. For example NSOperationQueue in Leopard took in NSOperation objects and created a thread,ran the NSOperation -(void)main on the thread and then killed the thread and repeated the process for each NSOperation object it ran,pretty much all we did on Leopard and earlier was creating threads,running them and then killing the threads. Grand Central dispatch however has a pool of threads. When you call into GCD it will give you a thread that you run your code on and then when it''s done it will give the thread back to GCD. Additionally queues in GCD will (when they have multiple blocks to run) just keep the same thread(s) running and run multiple blocks on the thread,which gives you a nice speed boost,and only then when it has no more work to do hand the thread back to GCD. So with GCD on SNow Leopard we are getting a nice speed boost just by using it because we are reusing resources over and over again and then we we aren''t using them we just give them back to the system.
 
 This makes GCD very nice to work with,it''s very fast,efficient and light on your system. Even though GCD is fast and light however you should make sure that when you give blocks to GCD that there is enough work to do such that it''s worth it to use a thread and concurrency. You can also create as many queues as you want to match however many tasks you are doing,the only constraint is the memory available on the users system.
 
 GCD API So if we have a basic block again like this
 
^{ NSLog(@"Doing something"); }
 
 then to get this running on another thread all we need to do is use dispatch_async() like so...
 
dispatch_async(queue,^{
 NSLog(@"Doing something");
});
 
 so where did that queue reference come from? Well we just need to create or get a reference to a Grand Central dispatch Queue ( dispatch_queue_t ) like this
 
dispatch_queue_t queue = dispatch_get_global_queue(0,0);
 
 which just in case you''ve seen this code is equivalent to
 
dispatch_queue_t queue = dispatch_get_global_queue(disPATCH_QUEUE_PRIORITY_DEFAULT,245)"> In Grand Central dispatch the two most basic things you''ll deal with are queues (dispatch_queue_t) and the API''s to submit blocks to a queue such as dispatch_async() or dispatch_sync() and I''ll explain the difference between the two later on. For Now let''s look at the GCD Queues.
 
 The Main Queue The Main Queue in GCD is analogous to the main app thread (aka the AppKit thread.) The Main Queue cooperates with NSApplicationMain() to schedule blocks you submit to it to run on the main thread. This will be very handy to use later on,for Now this is how you get a handle to the main queue
 
dispatch_queue_t main = dispatch_get_main_queue();
 
 or you Could just call get main queue inside of a dispatch call like so
 
dispatch_async(dispatch_get_main_queue(),^ {....
 
 The Global Queues The next type of queue in GCD are the global queues. You have 3 of them of which you can submit blocks to. The only difference to them are the priority in which blocks are dequeued. GCD defines the following priorities which help you get a reference to each of the queues...
 
enum {
 disPATCH_QUEUE_PRIORITY_HIGH = 2,disPATCH_QUEUE_PRIORITY_DEFAULT = 0,disPATCH_QUEUE_PRIORITY_LOW = -2,};
 
 When you call dispatch_get_global_queue() with disPATCH_QUEUE_PRIORITY_HIGH as the first argument you''ve got a reference to the high global queue and so on for the default and low. As I said earlier the only difference is the order in which GCD will empty the queues. By default it will go and dequeue the high priority queue''s blocks,then dequeue the default queues blocks and then the low. This priority doesn''t really have anything to do with cpu time.
 
 Private Queues Finally there are the private queues,these are your own queues that dequeue blocks serially. You can create them like so
 
dispatch_queue_t queue = dispatch_queue_create("com.MyApp.AppTask",NULL);
 
 The first argument to dispatch_queue_create() is essentially a C string which represents the label for the queue. This label is important for several reasons
 

You can see it when running Debug tools on your app such as Instruments
 
 
If your app crashes in a private queue the label will show up on the crash report
 
 
As there are going to be lots of queues on 10.6 it''s a good idea to differentiate them
 

 By default when you create your private queues they actually all point to the default global queue. Yes you can point these queues to other queues to make a queue hierarchy using dispatch_set_target_queue(). The only thing Apple discourages is making an loop graph where you make a queue that points to another and another eventually winding back to pointing at the first one because that behavior is undefined. So you can create a queue and set it to the high priority queue or even any other queue like so
 
dispatch_queue_t queue = dispatch_queue_create("com.App.AppTask,0);
dispatch_queue_t high = dispatch_get_global_queue(disPATCH_QUEUE_PRIORITY_HIGH,NULL);

dispatch_set_target_queue(queue,high);
 
 If you wanted to you Could do the exact same with your own queues to create the queue hierarchies that I described earlier on.
 
 Suspending Queues Additionally you may need to suspend queue''s which you can do with dispatch_suspend(queue). This runs exactly like NSOperationQueue in that it won''t suspend execution of the current block,but it will stop the queue dequeueing any more blocks. You should be aware of how you do this though,for example in the next example it''s not clear at all what''s actually run
 
irst Block"); });
dispatch_async(queue,^{ NSLog(@"Second Block"); });
dispatch_async(queue,^{ NSLog(@"Third Block"); });

dispatch_suspend(queue);
 
 In the above example it''s not clear at all what has run,because it''s entirely possible that any combination of blocks may have run.
 
 Memory Management It may seem a bit odd,but even in fully Garbage Collected code you still have to call dispatch_retain() and dispatch_release() on your grand central dispatch objects,because as of right Now they don''t participate in garbage collection.
 
 Recursive Decomposition Now calling dispatch_async() is okay to run code in a background thread,but we need to update that work back in the main thread,how how would one go about this? Well we can use that main queue and justdispatch_async() back to the main thread from within the first dispatch_async() call and update the UI there. Apple has referred to this as recursive decomposition,and it works like this
 
dispatch_queue_t queue = dispatch_queue_create(“com.app.task”,NULL)
dispatch_queue_t main = dispatch_get_main_queue();

dispatch_async(queue,^{
 CGFLoat num = [self doSomeMassivecomputation];

 dispatch_async(main,^{
  [self updateUIWithNumber:num];
 });
});
 
 In this bit of code the computation is offloaded onto a background thread with dispatch_async() and then all we need to do is dispatch_async() back into the main queue which will schedule our block to run with the updated data that we computed in the background thread. This is generally the most preferable approach to using grand central dispatch is that it works best with this asynchronous design pattern. If you really need to use dispatch_sync() and absolutely make sure a block has run before going on for some reason,you Could accomplish the same thing with this bit of code
 
dispatch_sync(queue,^{
 num = [self doSomeMassivecomputation];
});

[self updateUIWithNumber:num];

dispatch_sync() works just like dispatch_async() in that it takes a queue as an argument and a block to submit to the queue,but dispatch_sync() does not return until the block you''ve submitted to the queue has finished executing. So in other words the [self updateUIWithNumber:num]; code is guaranteed to not execute before the code in the block has finished running on another thread. dispatch_sync() will work just fine,but remember that Grand Central dispatch works best with asynchronous design patterns like the first bit of code where we simply dispatch_async() back to the main queue to update the user interface as appropriate.

dispatch_apply() dispatch_async() and dispatch_sync() are all okay for dispatching bits of code one at a time,but if you need to dispatch many blocks at once this is inefficient. You Could use a for loop to dispatch many blocks,but luckly GCD has a built in function for doing this and automatically waiting till the blocks all have executed. dispatch_apply() is really aimed at going through an array of items and then continuing execution of code after all the blocks have executed,like so

//Make sure GCD dispatches a block only 1 time
dispatch_once()

//dispatch a Block after a period of time
dispatch_after()

//Print Debugging information
dispatch_debug()

//Create a new dispatch source to monitor low-level System objects
//and automatically submit a handler block to a dispatch queue in response to events.
dispatch_source_create() 

NSOperationQueue *queue = [[NSOperationQueue alloc] init];
NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
 NSLog(@"Doing something...");
}];

//you can add more blocks
[operation addExecutionBlock:^{
 NSLog(@"Another block");
}];

[operation setCompletionBlock:^{
 NSLog(@"Doing something once the operation has finished...");
}];

[queue addOperation:operation];

//non concurrent dictionary enumeration with a block
[dict enumerateKeysAndobjectsUsingBlock:^(id key,id obj,BOOL *stop) {
  NSLog(@"Enumerating Key %@ and Value %@",key,obj);
 }];

//concurrent dictionary enumeration with a block
[dict enumerateKeysAndobjectsWithOptions:NSEnumerationConcurrent
    usingBlock:^(id key,BOOL *stop) {
     NSLog(@"Enumerating Key %@ and Value %@",obj);
    }];

解决方法