grand-central-dispatch

Lately I've been using dispatch_after instead of performSelector:withObject:afterDelay when I want to trigger some code after a delay. The code is cleaner, it has access to the enclosing scope, I can put the code in-line instead of writing a throw-away method, etc, etc. My code might look like this: dispatch_after(dispatch_time(DISPATCH_TIME_NOW, delay * NSEC_PER_SEC), dispatch_get_main_queue(), ^{ //Delayed-execution code goes here. } ); However, I recently discovered that the time-to-excution from this code seems to run pretty consistently about 10% slower than requested. If I ask for a

Edit I read through some articles on blocks and fast enumeration and GCD and the like. @Bbum, who's written many articles on the subject of GCD and blocks, says that the block enumeration methods are always as fast or faster than the fast enumeration equivalents. You can read his reasoning here . While this has been a fascinating, intellectual conversation, I agree with those who said that it really depends on the task at hand. I have some tasks to accomplish and I need them done fast, cheap, and efficiently. Apple gives us many choices for how we want to enumerate an array, but I'm not sure

(UPDATED) this is the problem in a nutshell: in iOS I want to read a large file, do some processing on it (in this particular case encode as Base64 string() and save to a temp file on the device. I set up an NSInputStream to read from a file, then in (void)stream:(NSStream *)stream handleEvent:(NSStreamEvent)eventCode I'm doing most of the work. For some reason, sometimes I can see the NSInputStream just stops working. I know because I have a line NSLog(@"stream %@ got event %x", stream, (unsigned)eventCode); in the beginning of (void)stream:(NSStream *)stream handleEvent:(NSStreamEvent

I'm trying these two approaches: dispatch_async(dispatch_get_main_queue(),^{ [self handleClickAsync]; }); and [self performSelector:@selector(handleClickAsync) withObject:nil afterDelay:0]; in response to a button press. The second allows the UIButton to highlight as one would expect and perform the handleClickAsync on the next run loop (I suppose: "sometime later" for sure). The first does not allow the UIButton instance to light up until the operation is completely done. What is the correct way to do this with GCD, or is performSelector still the only way? I believe the answer is found here

I have some data calculation method (let it be "myMethod:"), and I want to move the call to another thread because I don't want to block my main UI functionality. So, started to do some research on how to call my method on another thread. As far as I see, currently, there are a lot of different ways for doing that. Here's a list: a) using pure threads (available since iOS 2.0): [NSThread detachNewThreadSelector:@selector(myMethod:) toTarget:self withObject:_myParamsArray]; b) using a simple shortcut (available since iOS 2.0). Available from inherited NSObject but the method belongs to NSThread

I'm using some tricks to try to read the raw output of an AVAssetWriter while it is being written to disk. When I reassemble the individual files by concatenating them, the resulting file is the same exact number of bytes as the AVAssetWriter's output file. However, the reassembled file will not play in QuickTime or be parsed by FFmpeg because there is data corruption. A few bytes here and there have been changed, rendering the resulting file unusable. I assume this is occurring on the EOF boundary of each read, but it isn't consistent corruption. I plan to eventually use code similar to this

I'm writing a moderately complex iOS program that needs to have multiple threads for some of its longer operations (parsing, connections to the network...etc). However, I'm confused as to what the difference is between dispatch_get_global_queue and dispatch_queue_create . Which one should I use and could you give me a simple explanation of what the difference is in general? Thanks. As the documentation describes, a global queue is good for concurrent tasks (i.e. you're going to dispatch various tasks asynchronously and you're perfectly happy if they run concurrently) and if you don't want to