Работа с параллелизмом в Swift

Работа с параллелизмом в Swift

Как разработчик iOS, я столкнулся с проблемой параллелизма в своем коде. Независимо от того, пытаетесь ли вы обновить пользовательский интерфейс из фонового потока или имеете дело с условиями гонки, параллелизм может быть сложной темой для навигации. Но не бойтесь! В этой статье я поделюсь некоторыми советами и рекомендациями по работе с параллелизмом в Swift, которые, надеюсь, сделают вашу жизнь немного проще.

Что такое параллелизм?

Прежде всего, давайте поговорим о том, почему параллелизм важен. Короче говоря, параллелизм позволяет вашему приложению делать несколько вещей одновременно, что может привести к более быстрому и более отзывчивому взаимодействию с пользователем. Например, если вы загружаете данные из Интернета, вы не хотите блокировать основной поток и мешать пользователю взаимодействовать с вашим приложением. Вместо этого вы можете использовать параллелизм для загрузки данных в фоновом режиме, при этом позволяя пользователю использовать ваше приложение.

Теперь давайте поговорим о некоторых механизмах, которые Swift предоставляет для работы с параллелизмом.

Механизмы

Центральная диспетчерская (GCD)

GCD — это мощная платформа, позволяющая асинхронно выполнять задачи в очереди отправки. Очередь отправки — это очередь задач, которые выполняются одна за другой в том порядке, в котором они добавляются в очередь. Существует два типа очередей отправки: последовательные и параллельные. Последовательная очередь выполняет задачи по одной, в то время как параллельная очередь может выполнять несколько задач одновременно.

Чтобы использовать GCD, вы просто создаете очередь отправки, а затем добавляете задачи в очередь, используя методы async или sync. Метод async добавляет задачу в очередь и немедленно возвращается, тогда как метод sync блокирует текущий поток до тех пор, пока задача не завершится.

Вот пример того, как использовать GCD для загрузки данных из Интернета:

let url = URL(string: "https://www.example.com/data.json")!
DispatchQueue.global().async {
    if let data = try? Data(contentsOf: url) {
        // Do something with the data
    }
}

В этом примере мы используем глобальную параллельную очередь для загрузки данных с URL-адреса в фоновом режиме. Обратите внимание, что мы используем метод async для добавления задачи в очередь, что позволяет нам продолжать выполнение кода в основном потоке, пока задача выполняется в фоновом режиме.

Очереди операций

Очереди операций — еще один мощный механизм для работы с параллелизмом в Swift. Очередь операций — это очередь операций, которые выполняются асинхронно. Операция — это инкапсуляция задачи, которая может быть простым блоком кода или более сложным объектом, соответствующим протоколу Operation.

Одним из преимуществ использования очередей операций является то, что они обеспечивают больший контроль над выполнением задач, чем GCD. Например, вы можете указать зависимости между операциями, что позволит вам гарантировать, что одни операции будут раньше других.

Вот пример того, как использовать очередь операций для загрузки данных из Интернета:

let url = URL(string: "https://www.example.com/data.json")!
let downloadOperation = BlockOperation {
    if let data = try? Data(contentsOf: url) {
        // Do something with the data
    }
}
let operationQueue = OperationQueue()
operationQueue.addOperation(downloadOperation)

В этом примере мы создаем BlockOperation, который загружает данные с URL-адреса и добавляет их в очередь операций. Обратите внимание, что в этом примере мы не указываем никаких зависимостей между операциями, но вы можете сделать это, используя метод addDependency в классе Operation.

Асинхронный/ожидание

Async/Await — это функция, представленная в Swift 5.5, которая позволяет писать асинхронный код в более синхронном стиле. Это позволяет вам писать асинхронный код, который выглядит и ведет себя как синхронный код, что может сделать ваш код более легким для чтения и анализа.

Чтобы использовать Async/Await, вы определяете функцию как async и используете ключевое слово await для ожидания завершения асинхронной задачи. Например, вот как вы можете использовать Async/Await для загрузки данных из Интернета:

func downloadData() async throws -> Data {
    let url = URL(string: "https://www.example.com/data.json")!
    let (data, _) = try await URLSession.shared.data(from: url)
    return data
}

В этом примере мы определяем функцию downloadData, которая загружает данные с URL-адреса с помощью URLSession API. Обратите внимание, что мы используем ключевое слово await для ожидания завершения загрузки данных, из-за чего функция выглядит синхронной, хотя на самом деле она асинхронная.

Теперь, когда мы рассмотрели механизмы, которые Swift предоставляет для работы с параллелизмом, давайте поговорим о некоторых передовых методах написания параллельного кода.

Лучшие практики

Избегайте блокировки основного потока

Основной поток отвечает за обновление пользовательского интерфейса, поэтому очень важно избегать его блокировки длительными задачами. Чтобы избежать блокировки основного потока, следует использовать фоновые потоки или асинхронные API для выполнения трудоемких задач.

Вот пример того, как использовать фоновый поток для загрузки данных из Интернета:

func downloadData() {
    DispatchQueue.global(qos: .userInitiated).async {
        let url = URL(string: "https://www.example.com/data.json")!
        let (data, _) = try! URLSession.shared.data(from: url)
        // Do something with the downloaded data on a background thread
        DispatchQueue.main.async {
            // Update the UI with the downloaded data on the main thread
        }
    }
}

В этом примере мы используем метод global(qos:) для DispatchQueue для создания фонового потока с высоким качеством обслуживания. Затем мы загружаем данные из Интернета в фоновом потоке, используя URLSession API.

После загрузки данных мы используем DispatchQueue.main.async для обновления пользовательского интерфейса загруженными данными в основном потоке. Это важно, поскольку все обновления пользовательского интерфейса должны выполняться в основном потоке.

Используя фоновый поток для выполнения загрузки, а затем обновляя пользовательский интерфейс в основном потоке, мы можем избежать блокировки основного потока и гарантировать, что наше приложение останется отзывчивым.

Стоит отметить, что вы всегда должны обрабатывать ошибки при использовании асинхронных API, и вы никогда не должны принудительно разворачивать необязательные параметры, как мы сделали в этом примере. Это всего лишь упрощенный пример, иллюстрирующий концепцию использования фоновых потоков, чтобы избежать блокировки основного потока.

Избегайте общего состояния

Одной из самых больших проблем при работе с параллелизмом является работа с общим состоянием, которое представляет собой любые данные, к которым могут обращаться несколько потоков одновременно. Когда несколько потоков получают доступ к общему состоянию, вы можете столкнуться с такими проблемами, как условия гонки и взаимоблокировки.

Чтобы избежать этих проблем, лучше свести к минимуму количество общего состояния в вашем коде. Если вам нужно разделить состояние между потоками, используйте механизмы синхронизации, такие как блокировки и семафоры, чтобы обеспечить безопасный доступ к состоянию.

Вот пример того, как вы можете изменить класс, чтобы избежать разделяемого состояния:

class Counter {
    private var count = 0
    private let queue = DispatchQueue(label: "counterQueue", attributes: .concurrent)
    
    func increment() {
        queue.async(flags: .barrier) {
            self.count += 1
        }
    }
    
    func getCount() -> Int {
        var result = 0
        queue.sync {
            result = self.count
        }
        return result
    }
}

В этом примере у нас есть класс Counter, который поддерживает значение счетчика. Чтобы избежать совместного использования состояния, мы сделали переменную count приватной, поэтому доступ к ней возможен только внутри класса. Мы также добавили частную очередь, которую будем использовать для синхронизации доступа к переменной count.

Мы изменили метод increment, чтобы использовать метод async(flags: .barrier) в нашей очереди. Этот метод гарантирует, что любые другие задачи, которые также используют очередь, будут ожидать завершения задачи увеличения перед выполнением. Это предотвращает одновременное изменение переменной count любыми другими задачами, что может привести к условиям гонки.

Мы также добавили метод getCount, который использует метод sync в нашей очереди. Этот метод блокирует текущий поток до тех пор, пока не будет выполнено закрытие, что гарантирует, что только одна задача может получить доступ к переменной count за раз. Это предотвращает чтение переменной count другими задачами во время ее изменения, что может привести к противоречивым результатам.

Используя приватную очередь для синхронизации доступа к переменной count, мы избежали общего состояния и сделали наш класс Counter потокобезопасным.

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

Используйте группы рассылки

Диспетчерские группы — полезный механизм для координации выполнения нескольких задач. Группа отправки позволяет вам дождаться завершения группы задач, прежде чем продолжить выполнение.

Вот пример того, как использовать группу рассылки для параллельной загрузки данных с нескольких URL-адресов:

let urls = [
    URL(string: "https://www.example.com/data1.json")!,
    URL(string: "https://www.example.com/data2.json")!,
    URL(string: "https://www.example.com/data3.json")!,
]
let group = DispatchGroup()
for url in urls {
    group.enter()
    URLSession.shared.dataTask(with: url) { _, _, _ in
        group.leave()
    }.resume()
}
group.wait()

В этом примере мы используем Dispatch Group для ожидания завершения трех параллельных загрузок данных. Обратите внимание, что мы используем методы enter и leave в группе отправки, чтобы гарантировать уведомление группы о завершении каждой задачи.

Дизайн для параллелизма

При разработке кода подумайте, как он будет использоваться в параллельной среде. Избегайте глобального состояния, сделайте ваши объекты потокобезопасными и спроектируйте свои API так, чтобы они были асинхронными и неблокирующими.

Заключение

Работа с параллелизмом может быть сложной задачей, но с помощью механизмов и рекомендаций, изложенных в этой статье, вы должны быть хорошо подготовлены к решению проблем параллелизма в своем коде Swift. Не забывайте, насколько это возможно, избегать общего состояния, используйте механизмы координации, такие как группы отправки, когда это уместно, и выбирайте механизм параллелизма, который лучше всего соответствует вашим потребностям.

Удачного кодирования!