2026 Swift 6.2 SwiftData: как поэтапно перестроить слой данных для конкурентности?

По официальным примечаниям к начальной версии Xcode 26 в неё входит Swift 6.2, тогда как Xcode 26.6 уже содержит Swift 6.3. Победитель для поддерживаемого старого проекта очевиден: поэтапная конкурентная переработка SwiftData в Swift 6.2, но только после фиксации конкретного toolchain и воспроизводимой цепочки записи. Сначала следует отказаться от глобального @MainActor, затем замкнуть одну рискованную запись в @ModelActor, а через границу передавать PersistentIdentifier или Sendable DTO. @unchecked Sendable не должен быть способом массово убрать диагностику.
Эта статья предназначена для разработчиков, которые продолжают выпускать приложение на ветке Swift 6.2 и не могут остановить работу ради полной замены слоя хранения. Она также полезна архитекторам, разделяющим владение ModelContext, и техническим руководителям, которым нужно параллельно проверять старую и новую ветки на независимых Mac-средах.
Исходная точка: неудачный глобальный ремонт
Типичный неудачный коммит выглядит убедительно: почти весь слой SwiftData получает @MainActor, проект снова компилируется, а часть предупреждений исчезает. Через некоторое время экран списка начинает задерживаться при импорте, редактор перестаёт отвечать во время серии сохранений, а фоновая задача ждёт результат, который должен обработать главный актор.
Это не доказательство того, что внутри SwiftData произошёл настоящий deadlock. Возможны разные причины:
- проверка изоляции не прошла на этапе компиляции;
- объект или замыкание пересекли Actor-границу неправильно;
ModelContextвыполняет работу на главном акторе и блокирует интерфейс;- две операции ждут друг друга;
- приложение действительно застряло, но это нужно подтвердить выборкой потоков и стеком вызовов.
ModelActor даёт взаимно исключённый доступ к свойствам модели, но сама аннотация не доказывает, что любое зависание вызвано внутренней блокировкой базы. Публичная семантика ModelContext и ModelActor описана в документации ModelContext и документации ModelActor. Диагноз «deadlock» допустим только после проверки активных потоков и стека.
До изменений нужно сохранить:
- текущую ветку и точный commit;
- язык Swift для каждого target;
- режим проверки конкурентности;
- настройку default actor isolation;
- минимальный тест, воспроизводящий вставку, обновление или импорт;
- журналы, скриншоты диагностики и стек при зависании.
Swift 6 не включается автоматически для всех старых приложений. Языковой режим выбирается проектом и target. Поведение default actor isolation также связано с настройками и предложениями языка, а не с универсальным приказом автоматически пометить весь старый код. Это следует проверять по предложению о default actor isolation.
Какая цепочка должна стать первой? Не самая большая и не самая удобная для демонстрации. Лучше выбрать один поток с высокой ценой ошибки: импорт, пакетное обновление или создание записи после сетевого ответа. У него должна быть наблюдаемая граница: входные данные, операция сохранения, результат и возможность отката.
Первый час: карта владения данными
Вместо чтения всего проекта нужно нарисовать одну цепочку:
UI state → команда приложения → фоновая операция → ModelContext → save().
Для каждого узла фиксируется владелец:
ModelContainer— кто создаёт и передаёт его;ModelContext— где он создан и на каком акторе используется;- экземпляр
@Model— каким контекстом управляется; - состояние интерфейса — какие поля реально нужны экрану;
- фоновая задача — кто её отменяет и кто обрабатывает ошибку.
Особенно опасны три неявные передачи:
@Modelотправляется из фонового контекста на главный актор;- замыкание захватывает контекст, созданный в другом домене изоляции;
- сервис принимает чужой
ModelContext, а затем вызывающий код продолжает работать с тем же контекстом параллельно.
На этой стадии не следует исправлять всё найденное сразу. Для выбранной цепочки нужно собрать четыре доказательства:
- сообщение компилятора;
- стек вызова в момент ошибки;
- выборку потоков при зависании;
- результат минимального теста на повторный запуск и отмену.
Так отделяется ошибка проверки типов от проблем активности. Если компилятор сообщает об отсутствии Sendable, это ещё не означает, что приложение может войти в deadlock. Если интерфейс кратко перестаёт отвечать, это ещё не означает циклическое ожидание.
Первый коммит: узкая граница ModelActor
Первый коммит должен изменить только выбранную запись. Его задача — не сделать архитектуру красивой, а создать один проверяемый домен владения.
Упрощённая форма может выглядеть так:
import SwiftData
@ModelActor
actor ImportStore {
func insertRecord(
title: String,
externalID: String
) throws -> PersistentIdentifier {
let record = Record(title: title, externalID: externalID)
modelContext.insert(record)
try modelContext.save()
return record.persistentModelID
}
}
Здесь важны не названия типов, а граница:
- актор сам работает со своим
modelContext; - вызывающая сторона передаёт значения, а не экземпляр
Record; - вставка и сохранение находятся в одной операции;
- результатом становится идентификатор, а не управляемый объект.
Конкретный инициализатор @ModelActor зависит от способа внедрения ModelContainer, поэтому его нельзя превращать в универсальный шаблон для любой архитектуры. В приложении контейнер должен создаваться в согласованной композиционной точке и передаваться в слой данных через зависимость. Нельзя незаметно создавать новый контейнер для каждой операции: это изменит жизненный цикл хранилища и усложнит проверку результата.
С чего начинать переработку слоя SwiftData? С одной записи или пакетного импорта, где можно зафиксировать вход, сохранение и выход. Не следует начинать с общего протокола «для всех репозиториев»: такой протокол часто скрывает владельца контекста и переносит проблему в другое место.
| Вариант изменения | Граница владения | Что передаётся через Actor | Когда выбирать | Главный риск |
|---|---|---|---|---|
Глобальный @MainActor |
Весь слой фактически привязан к главному актору | Модели и замыкания остаются рядом | Только для действительно UI-ориентированного состояния | Фоновая запись начинает блокировать интерфейс |
Узкий @ModelActor |
Одна операция записи и её контекст | Значения, идентификаторы, DTO | Для первого безопасного шага | Можно ошибочно расширить актор до всего приложения |
@unchecked Sendable |
Граница объявляется безопасной вручную | Почти любой объект | Лишь для строго доказанного внешнего типа | Ошибка компилятора скрыта, а гонка остаётся |
Прямой обмен @Model |
Контекст фактически разделяется | Управляемый объект | Не выбирать для межакторного контракта | Нарушение владения и сложная диагностика |
Важный признак хорошего первого коммита — его можно отключить флагом или вернуть старую реализацию без удаления исходной цепочки. Если откат требует менять UI, контейнер и все сервисы одновременно, граница выбрана слишком широко.
Тот же день: новый контракт результата
После создания ModelActor нужно заменить не только вход, но и выход. Возвращать @Model обратно на MainActor обычно означает переносить объект, связанный с другим контекстом. Это как раз тот случай, когда компилятор пытается защитить проект от неясного владения.
Должен ли @ModelActor возвращать модель или отправляемые данные? Для межакторного интерфейса безопаснее возвращать PersistentIdentifier, неизменяемую структуру или явно Sendable DTO. Управляемую модель следует заново получить в контексте принимающей стороны, если экрану действительно нужны её данные.
Например:
struct RecordSummary: Sendable {
let id: PersistentIdentifier
let title: String
}
@ModelActor
actor RecordStore {
func createSummary(title: String) throws -> RecordSummary {
let record = Record(title: title)
modelContext.insert(record)
try modelContext.save()
return RecordSummary(
id: record.persistentModelID,
title: record.title
)
}
}
PersistentIdentifier предназначен именно для идентификации персистентной модели; его публичное назначение описано в документации PersistentIdentifier. Идентификатор не переносит сам объект и не передаёт владельца контекста.
На главном акторе UI может получить DTO и обновить состояние. Если требуется полная модель, UI использует собственный ModelContext и заново запрашивает объект по идентификатору. Такой запрос должен быть частью UI-контекста, а не попыткой повторно использовать modelContext фонового актора.
Как выполнять фоновую запись, не передавая модель на главный актор? Фоновая операция принимает обычные значения, создаёт или изменяет запись внутри собственного ModelActor, сохраняет её и возвращает идентификатор либо DTO. Главный актор получает только результат операции. Семафор, DispatchQueue.sync, ожидание через ручной сигнал или автономный Task, чей жизненный цикл никто не контролирует, не являются исправлением.
Обработка отмены и ошибок тоже должна оставаться структурированной:
func runImport() async {
do {
let result = try await store.createSummary(title: inputTitle)
await MainActor.run {
state = .loaded(result)
}
} catch is CancellationError {
state = .cancelled
} catch {
state = .failed(error)
}
}
Фактическая форма зависит от изоляции UI-состояния. Смысл остаётся прежним: операция имеет владельца, отмена доходит до неё, а UI получает значение, а не контекст.
Первый день: проверяем границу, а не впечатление
После первого коммита нужно запустить минимальный тест в нескольких режимах:
- одна вставка;
- две последовательные вставки;
- непрерывная серия записей;
- отмена во время операции;
- переход приложения в фон;
- повторное открытие экрана;
- запрос результата в UI-контексте.
Каждый режим должен сохранять результат, ошибку и отмену. Если экран «стал быстрее», это полезное наблюдение, но не критерий завершения. Нужны компиляция без прежней диагностики, отсутствие передачи модели через Actor-границу и совпадение количества ожидаемых записей.
Следует отдельно собрать выборку потоков при зависании. Если стек указывает на ожидание синхронной очереди, это одна проблема. Если поток занят запросом, это другая. Если несколько задач ждут друг друга, появляется основание обсуждать циклическое ожидание. Без этих данных нельзя объявлять исправление deadlock.
@ModelActor не следует расширять на чтение, UI-команды и сетевой слой только ради симметрии. Чем шире актор, тем больше операций выстраивается в одну последовательную область. Это может быть правильной моделью для конкретного хранилища, но должно быть осознанным решением, а не побочным эффектом аннотации.
Первая неделя: миграция вызовов и удаление обходов
Когда первая цепочка доказала свою работоспособность, миграция выполняется по вызовам. Один коммит — одна наблюдаемая граница. Старый путь сохраняется за переключателем или адаптером, пока новый путь не прошёл регрессию.
Можно ли перенести только один target или один модуль данных? Да, если его публичный контракт не выпускает наружу @Model, ModelContext и незащищённые замыкания. На границе модуля должны находиться DTO, идентификаторы, ошибки и команды. Остальные targets могут временно использовать старую реализацию, но не должны получать внутренний контекст нового актора напрямую.
Во время миграции составляется список временных обходов:
@unchecked Sendable;@preconcurrency;Task.detached;- расширенный
@MainActor; - ручные синхронные очереди;
- скрытые singleton-контексты.
Каждая запись в списке должна иметь причину, область действия и условие удаления. Если сторонняя зависимость ещё не адаптирована, совместимость ограничивается краем модуля. Не следует помечать @unchecked Sendable бизнес-модели, чтобы заставить компилятор замолчать.
@preconcurrency может временно облегчить взаимодействие с устаревшим API, но не доказывает безопасность. Task.detached меняет наследование контекста и потому особенно опасен для кода, который захватывает состояние SwiftData. Расширение @MainActor допустимо для UI-состояния, но не как универсальная оболочка базы.
Как сохранить откат во время конкурентной переработки? Сохранить старый сервис за тем же приложенческим протоколом, добавить переключатель реализации и оставить одинаковые входные тестовые данные. Новый адаптер должен возвращать тот же DTO или результат операции. После миграции очередного вызова старый путь не удаляется до завершения проверки; затем временный флаг и обход убираются отдельным коммитом.
В команде, которая ведёт несколько веток, полезно держать отдельный журнал: target, выбранный toolchain, режим Swift, путь данных, статус нового актора и причина оставшегося обхода. Для доступа к выделенной Mac-среде и проверки разных рабочих сессий можно использовать консоль ProxyMac, а инструкции по подключению и работе с окружением — сверять в справочном разделе ProxyMac. Это не заменяет локальную диагностику: среда должна подтвердить воспроизводимость, а не скрыть проблему.
Перед расширением: много сред и откат
Финальная проверка первой цепочки проводится на фиксированном наборе данных. В него входят обычная запись, повторная запись, отмена, переход приложения в фон, несколько одновременно запущенных окон или расширений и восстановление после ошибки сохранения.
Проверять нужно минимум две конфигурации процесса:
- текущую ветку, которая ещё поставляется на Swift 6.2;
- планируемую ветку с обновлённым toolchain.
Связь между результатами нельзя объяснять только состоянием DerivedData, симулятора или одной рабочей станции. Перед сравнением следует очистить производные артефакты, повторить тест на независимом окружении и сохранить диагностический вывод. Это особенно важно для старого проекта, в котором часть настроек могла остаться на уровне отдельного target.
Когда можно переносить метод на остальные модули? Только после трёх подтверждений для первой цепочки: код компилируется с выбранным режимом конкурентности, операция не блокирует интерфейс по данным выборки и после повторного чтения сохраняется согласованное состояние данных. Если один из пунктов не выполнен, расширение миграции откладывается, а старый путь остаётся доступным.
Swift Evolution отдельно описывает изоляцию async-функций и переходы между контекстами в предложении о function isolation. Это полезная проверка для контрактов, но предложение не превращает любой тип в безопасный для передачи. Для каждого DTO всё равно нужно проверить изменяемость полей, захваты замыканий и жизненный цикл операции.
Если после переноса первой записи всё ещё наблюдается зависание, следующий шаг — не добавить ещё одну аннотацию. Нужно вернуть минимальный тест, снять стек потоков и установить, где именно прекращается продвижение: в очереди UI, в запросе, в ожидании задачи или в последовательной области актора.
Итоговый маршрут для старого проекта
Последовательность получается такой:
- зафиксировать Swift 6.2, target-настройки и исходный симптом;
- выбрать одну рискованную цепочку записи;
- разделить ошибку компиляции, нарушение изоляции, блокировку UI и доказанный deadlock;
- создать узкий
@ModelActorс собственнымModelContext; - передавать значения, а возвращать
PersistentIdentifierилиSendableDTO; - повторно получать модель в контексте принимающей стороны;
- сохранить старую реализацию и переключатель отката;
- проверить отмену, фон, повторные записи и независимую среду;
- удалить временные обходы только после прохождения цепочки;
- затем переносить следующий вызов.
Такой подход медленнее глобального @MainActor только на уровне первого коммита. Зато он показывает, какая граница действительно исправлена. Для Swift 6.2 это важнее количества исчезнувших предупреждений.
Если текущая схема — один общий ModelContext, синхронные возвраты на главный поток и ручные обходы Sendable, её слабые места уже видны: интерфейс получает чужое владение, фоновые операции могут конкурировать за одну точку доступа, а откат становится связанным с десятками вызовов. Самостоятельная локальная машина добавляет ещё один фактор — кэш, состояние симулятора и невозможность быстро сравнить две ветки. Для первой цепочки разумнее подготовить независимое Mac-окружение через ProxyMac, запустить старый и новый варианты отдельно, а затем продолжить миграцию по фактам, а не по ощущению от одного рабочего места. Начать можно с описания доступных сценариев ProxyMac, оставив аренду именно для временной проверки, параллельной ветки или воспроизводимого тестового окружения, а не как замену постоянной инфраструктуре команды.