Что лучше при многопоточности: структура или класс?

Структура или класс для многопоточности в Swift

При работе с многопоточностью в Swift выбор между структурой (struct) и классом (class) имеет фундаментальное значение, поскольку влияет на поведение данных в параллельных потоках. Ответ не является абсолютным — он зависит от конкретного контекста и требований к безопасности данных.

Ключевое различие: семантика типа

Основная разница между структурой и классом заключается в семантике типа:

• Структуры имеют семантику значения (value semantics). Каждая переменная хранит независимую копию данных.
• Классы имеют семантику ссылки (reference semantics). Все переменные ссылаются на один экземпляр в памяти.

// Пример с классом (семантика ссылки)
class SharedCounter {
    var value = 0
}

let counterA = SharedCounter()
let counterB = counterA
counterA.value += 1
print(counterB.value) // 1 — обе переменные изменяют один объект

// Пример со структурой (семантика значения)
struct IndependentCounter {
    var value = 0
}

var counterC = IndependentCounter()
var counterD = counterC
counterC.value += 1
print(counterD.value) // 0 — каждая переменная имеет свою копию

Почему структуры часто предпочтительнее в многопоточной среде

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

1. Избегание неявного общего состояния. Когда вы передаете структуру между потоками, каждый поток получает свою независимую копию. Это устраняет риск одновременного изменения одного объекта из разных потоков без синхронизации.

2. Отсутствие необходимости в сложных механизмах синхронизации. Для многих структур можно избежать использования мьютексов (Mutex), семафоров (Semaphore) или NSLock, поскольку данные локальны для каждого потока.

3. Потокобезопасность по умолчанию. Если структура состоит только из let-констант и не содержит изменяемых (var) свойств, она иммутабельна (immutable) и полностью безопасна для чтения из любого потока.

// Потокобезопасная структура — иммутабельна
struct ImmutableConfig {
    let serverURL: String
    let timeout: TimeInterval
}
// Можно свободно передавать между потоками без риска

Когда классы могут быть необходимы

В некоторых сценариях классы остаются подходящим выбором:

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

class SharedCache {
    private var storage: [String: Data] = []
    private let lock = NSLock()
    
    func set(_ key: String, data: Data) {
        lock.lock()
        storage[key] = data
        lock.unlock()
    }
}

1. Объекты с жизненным циклом или делегатами. Классы необходимы, когда нужна совместная работа через ссылки (например, делегаты в URLSession).

2. Высокая производительность при больших данных. Если объект очень большой и его копирование между потоками дорого, можно использовать класс с тщательной синхронизацией. Однако в Swift структуры с копированием при записи (Copy-on-Write) оптимизируют эту проблему для многих типов (например, Array, Dictionary).

Практические рекомендации

• Начинайте с структуры. Если ваши данные не требуют явного общего состояния, используйте struct. Это безопаснее и часто приводит к более простому коду.
• Если нужно общее состояние — защищайте его. При использовании класса для ресурсов, доступных из нескольких потоков, обязательно применяйте синхронизацию (synchronization): DispatchQueue с барьерами, NSLock, семафоры или атомарные операции.
• Рассмотрите гибридные подходы. Например, можно иметь класс, который управляет синхронизированным состоянием, но предоставляет потокам копии данных в виде структур для локальной работы.

struct UserData {
    var name: String
    var score: Int
}

class UserManager {
    private var currentUser: UserData
    private let queue = DispatchQueue(label: "user.sync", attributes: .concurrent)
    
    func updateScore(_ newScore: Int) {
        queue.sync(flags: .barrier) {
            currentUser.score = newScore
        }
    }
    
    func getUserCopy() -> UserData {
        return queue.sync {
            currentUser
        }
    }
}

Итог

В многопоточном программировании на Swift структуры обычно являются более безопасным и предпочтительным выбором благодаря их семантике значения, которая минимизирует риски гонок данных (data races). Классы следует использовать сознательно — только когда действительно необходимо общее состояние между потоками, и всегда сопровождать их надежными механизмами синхронизации. Ключевой принцип: избегайте неявного общего состояния, а если оно требуется — управляйте им явно и безопасно.