Как заставить один метод ждать завершения другого (асинхронного) метода, прежде чем продолжить выполнение?

Судя по вашему коду, похоже, что вы контролируете асинхронную отправку.

Вместо some_independent_async_call используйте dispatch_sync, что заблокирует выполнение в текущем потоке до тех пор, пока данный блок не завершится.

с использованием dispatch_sync в Grand Central Dispatch

Однако, если у вас нет контроля над асинхронным вызовом, и вы фактически вызываете метод для объекта, который затем переходит и вызывает dispatch_async; у вас нет выбора, чем использовать блок завершения, шаблон обратного вызова или семафор, как вы указали

Итак, если я правильно понял вашу проблему, у вас есть список «Элементов» и одна асинхронная задача. Задача принимает параметр item и вычисляет некоторый «результат» (массив целых чисел).

Теперь для каждого «элемента» будет оцениваться логическое значение, определяющее, следует ли запускать задачу с этим элементом в качестве аргумента.

По завершении каждой задачи (вашей some_independent_async_call) требуется вызвать продолжение (возможно, используя результат соответствующей выполненной задачи).

Что ж, это, безусловно, можно реализовать с помощью групп отправки, обработчиков завершения, NSOperations и тому подобного. Но это быстро станет довольно сложным и подверженным ошибкам, особенно если вы хотите обрабатывать ошибки и, возможно, реализовать средства для отмены задачи, если это необходимо. Но поскольку с «Фьючерсами» это становится невероятно просто, я предлагаю это решение.

Обратите внимание, что «фьючерсы» не включены в стандартную библиотеку Swift. Тем не менее, есть несколько доступных сторонних библиотек. Здесь я буду использовать "подобные Scala" фьючерсы. Обратите внимание, что это также может быть реализовано с помощью «Promises» аналогичным образом. См. также вики Фьючерсы и обещания.

Используя фьючерсы, задача имеет следующую подпись:

typealias TaskType = (Item) -> Future<SomeResult>

Будущее — это «заполнитель» для значения, которое будет вычислено позже базовой асинхронной задачей. Задача также может завершиться ошибкой и вместо значения вернуть ошибку. То есть будущее будет в конечном итоге завершено либо с результатом, либо с ошибкой.

Пусть задача будет:

func task(item: Item) -> Future<SomeResult> {
    let promise = Promise<SomeResult>()
    fetchSomeResult(item.url) { (result, error) in
        if let result = result {
            promise.fulfill(result)
        } else {
            promise.reject(error!)
        }
    }
    return promise.future!
}

Кажется проще отфильтровать массив, чтобы получить фактические «Элементы», которые запускают задачу:

let activeItems = items.filter { $0.foo == something }

Получить массив фьючерсов:

let futures = activeItems.map { task($0) } 

Приведенный выше оператор запускает асинхронные задачи, каждая из которых соответствует своему элементу и возвращает массив фьючерсов с типом [Future<SomeResult>]. В настоящее время фьючерсы еще не завершены. Это произойдет в конечном итоге для каждого будущего, когда основная задача завершится.

Теперь добавьте продолжение к каждому будущему, которое вызывается при успешном выполнении задачи, а также добавьте обработчик ошибок, который вызывается при их возникновении:

futures.forEach { future in
    future.map { result in
        // This will be entered for each task, once it 
        // finished successfully.
        // Handle result (should be your array of ints)
        // This is where you implement the "method2" part
        // but for each item separately.
        // Note: if you need the "item" as well, use a
        // task which returns a tuple:
        // task(item: Item) -> Future<(Item, SomeResult)>
    }.onFailure { error in
       // handle error. This is an error returned from the task.
    }
}