Java Executor：小任务还是大任务？(Java Executor: Small tasks or big ones?)

 同步调度会暂停代码的执行，直到调度块完成为止。 异步调度立即返回，该块与调用代码异步执行： 
 
dispatch_sync(somewhere, ^{ something });
// Reached later, when the block is finished.

dispatch_async(somewhere, ^{ something });
// Reached immediately. The block might be waiting
// to be executed, executing or already finished.
 
 并且有两种调度队列，串行和并发。 串行的按照添加顺序严格逐个发送块。 当一个完成时，另一个开始。 这种执行只需要一个线程。 并发队列并行地同时调度块。 那里使用了更多的线程。 
 
 如果您认为合适，您可以混合使用同步/异步调度和串行/并发队列。 如果您想要使用GCD来保护对关键部分的访问，请使用单个串行队列并分配此队列上共享数据的所有操作（同步或异步，无关紧要）。 这样，共享数据总是只有一个块操作： 
 
- (void) addFoo: (id) foo {
    dispatch_sync(guardingQueue, ^{ [sharedFooArray addObject:foo]; });
}

- (void) removeFoo: (id) foo {
    dispatch_sync(guardingQueue, ^{ [sharedFooArray removeObject:foo]; });
}
 
 现在，如果guardingQueue是一个串行队列，即使从不同线程同时调用addFoo:和removeFoo:方法，add / remove操作也不会发生冲突。 

Synchronous dispatch suspends the execution of your code until the dispatched block has finished. Asynchronous dispatch returns immediately, the block is executed asynchronously with regard to the calling code:
 
dispatch_sync(somewhere, ^{ something });
// Reached later, when the block is finished.

dispatch_async(somewhere, ^{ something });
// Reached immediately. The block might be waiting
// to be executed, executing or already finished.
 
And there are two kinds of dispatch queues, serial and concurrent. The serial ones dispatch the blocks strictly one by one in the order they are being added. When one finishes, another one starts. There is only one thread needed for this kind of execution. The concurrent queues dispatch the blocks concurrently, in parallel. There are more threads being used there.
 
You can mix and match sync/async dispatch and serial/concurrent queues as you see fit. If you want to use GCD to guard access to a critical section, use a single serial queue and dispatch all operations on the shared data on this queue (synchronously or asynchronously, does not matter). That way there will always be just one block operating with the shared data:
 
- (void) addFoo: (id) foo {
    dispatch_sync(guardingQueue, ^{ [sharedFooArray addObject:foo]; });
}

- (void) removeFoo: (id) foo {
    dispatch_sync(guardingQueue, ^{ [sharedFooArray removeObject:foo]; });
}
 
Now if guardingQueue is a serial queue, the add/remove operations can never clash even if the addFoo: and removeFoo: methods are called concurrently from different threads.