Это перевод статьи Concurrency Step-by-Step: Stateful Systems

В предыдущих первом и во втором постах я использовал исключительно систему только для чтения. Это далеко от реальных задач! Реальные приложения пишут данные в локальное хранилище, в удаленные сервисы и, как правило, находятся «по самые уши» в изменяемом состоянии.

В этом посте мы собираемся создать приложение SwiftUI, которое работает с изменяемым состоянием, размещенным на (мнимой) удаленной сетевой службе.

Краткие заметки

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

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

«Удаленная» (‘remote’) система

Для начала нам нужна какая-то удаленная (remote) служба для взаимодействия. Весь смысл этого упражнения — иметь дело с состоянием, поэтому важно, чтобы эта система сохраняла состояние. Но я не смог ее найти, поэтому мы просто притворимся.

final class RemoteSystem: @unchecked Sendable {
	private var state = false
	private let queue = DispatchQueue(label: "RemoteSystemQueue")

	func toggleState(completionHandler: @escaping @Sendable () -> Void) {
		queue.async {
			self.state.toggle()
			completionHandler()
		}
	}
	
	func readState(completionHandler: @escaping @Sendable (Bool) -> Void) {
		queue.async {
			completionHandler(self.state)
		}
	}
}

Это симуляция “удаленной” системы, которая управляет значением ровно одной булевой Bool переменной var state. Внешний мир может переключать или считывать текущее булевское Bool значение этой переменной state, но он должен делать это асинхронно.

Я уверен, вы также заметили, что я решил реализовать это с помощью Dispatch. Чтобы это работало со Swift 6, мы должны сообщить компилятору, что мы взяли на себя ответственность за потокобезопасность, отметив ТИП RemoteSystem как @unchecked Sendable. Нам также нужно несколько @Sendable замыканий.

Это перевод статьи Concurrency Step-by-Step: Reading from Storage

Тема, которая снова и снова возникает в связи с многопоточностью (concurrency) в Swift, — это попытка «сделать компилятор довольным». Вы просто хотите, чтобы глупые ошибки исчезли. Пытаясь сделать это, вы натыкаетесь на множество вещей, таких как Sendable или @preconcurrency. Вы даже можете начать менять класс class на актор actor , и непонятно, насколько это может отличаться, но это даже то же самое количество символов. Поэтому вы просто начинаете бросаться синтаксисом в проблему. Это понятно!

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

Добро пожаловать во вторую часть «Concurrency Swift шаг за шагом». Первая часть «Concurrency Swift шаг за шагом» находится здесь. Цель этих постов— проработать общую задачу, чтобы помочь сформировать реальное понимание того, что происходит. В прошлый раз мы рассматривали сетевой запрос. На этот раз мы загрузим модель из хранилища данных.

Краткие заметки

Я проигнорирую обработку ошибок, чтобы сосредоточиться на многопоточности.
Я не очень хорош в SwiftUI. Нам потребуется Xcode 16 или более поздняя версия.
Мне было очень трудно придумать пример, который был бы одновременно простым и иллюстрировал проблему. Я думаю, что локальное хранилище будет работать хорошо, но нам придется сделать его довольно надуманным. Я не думаю, что это действительно уведет нас от каких-либо идей. Но я все равно хочу это подчеркнуть, потому что идея «хранилища данных» здесь не будет похожа на SwiftData, CoreData или другие вещи, которые может использовать реальное приложение.

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

Расставляем детали по местам

Итак, начнем с определения интерфейса нашей системы хранения данных.

class DataModel {
	let name: String

	init(name: String) {
		self.name = name
	}
}

class Store {
	func loadModel(named name: String) async -> DataModel {
		DataModel(name: name)
	}
}

Я же говорил, что это будет надуманно!
Есть только ТИП DataModel для хранения простого значения name, а также Store, который «загружает» для нас модели. Ни один из них не делает ничего полезного. Но на самом деле нас интересуют только ТИПы и их интерфейсы.

Теперь нам нужен SwiftUI View, чтобы связать все это воедино.

struct ContentView: View {
	@State private var store = Store()
	@State private var name: String = "---"

	var body: some View {
		Text("hello \(name)!")
			.task {
				self.name = await store.loadModel(named: "friends").name
			}
	}
}

Этот фрагмент кода должен очень удобно поместиться на одном экране. Неплохо!

Отступление: система ТИПов

Я вставил небольшой комментарий выше, который заслуживает большего внимания.
Но на самом деле нас интересуют только ТИПы и их интерфейсы.
Это важно и довольно нетривиально!