Is there ever any reason to add blocks to a **serial dispatch queue** *asynchronously* as opposed to *synchronously*? 

As I understand it a serial dispatch queue only starts executing the next task in the queue once the preceding task has completed executing. If this is the case, I can't see what you would you gain by submitting some blocks *asynchronously* - the act of submission may not block the thread (since it returns straight-away), but the task won't be executed until the last task finishes, so it seems to me that you don't really gain anything.

This question has been prompted by the following code - taken from a book chapter on design patterns. To prevent the underlying `data` array from being modified simultaneously by two separate threads, all modification tasks are added to a serial dispatch queue. But note that `returnToPool` adds tasks to this queue *asynchronously*, whereas `getFromPool` adds its tasks *synchronously*. 

```
class Pool<T> {
    private var data = [T]();
    // Create a serial dispath queue
    private let arrayQ = dispatch_queue_create("arrayQ", DISPATCH_QUEUE_SERIAL);
    private let semaphore:dispatch_semaphore_t;

    init(items:[T]) {
        data.reserveCapacity(data.count);
        for item in items {
            data.append(item);
        }
        semaphore = dispatch_semaphore_create(items.count);
    }

    func getFromPool() -> T? {
        var result:T?;
        if (dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER) == 0) {
            dispatch_sync(arrayQ, {() in
                result = self.data.removeAtIndex(0);
            })
        }
        return result;
    }

    func returnToPool(item:T) {
        dispatch_async(arrayQ, {() in
            self.data.append(item);
            dispatch_semaphore_signal(self.semaphore);
        });
    }
}

```