{"draftJsState":{"blocks":[{"data":{"image":{"id":"64a48bcf4c574956ac2adf1d"}},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"atomic:image","key":"d78o4"},{"data":{},"depth":0,"entityRanges":[{"key":0,"length":22,"offset":10}],"inlineStyleRanges":[],"text":"Источник: Nuances of Programming","type":"unstyled","key":"cobff"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Почти в каждой статье об async/await на Swift появляются комментарии о @MainActor. Как применять его, чтобы любые обновления пользовательского интерфейса происходили в основном потоке?","type":"unstyled","key":"dc9i9"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Где именно должен быть атрибут @MainActor? В классе? Только в асинхронной функции? Внутри вложенного блока задач? В отдельных функциях, предназначенных исключительно для обновления потока? Может, задействовать что-то вроде await MainActor.run? Или DispatchQueue.main.async и просто забыть про все это?","type":"unstyled","key":"fn1lk"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"У многих свое мнение, и мы не исключение.","type":"unstyled","key":"fr08u"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Рассмотрим фактический код промежуточного языка Swift, генерируемый этими механизмами, изучим относительную эффективность, размер кода каждого из них и связанные с этим последствия.","type":"unstyled","key":"fant9"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Модель представления","type":"header-three","key":"4il3e"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Вот очень простая модель представления с двумя издателями, инициализатором, функциями load и process как элементом управления для понимания различий между обычной функцией и помеченной как асинхронная:","type":"unstyled","key":"13lcl"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"class ContentViewModel: ObservableObject {\n\n @Published var accounts: [Account]\n @Published var message: String?\n\n let loader: AccountLoader\n\n init(loader: AccountLoader) {\n self.accounts = []\n self.loader = loader\n }\n\n func load() async {\n do {\n accounts = try await loader.load()\n message = nil\n } catch {\n message = \"Unable to load\"\n }\n }\n\n func process(_ accounts: [Account]) {\n self.accounts = accounts\n }\n}","type":"blockquote","key":"d3uej"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"В службе AccountLoader просто содержится функция func load() async throws -> [Account], вызываемая для получения данных.","type":"unstyled","key":"f66ge"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"SIL — промежуточный язык Swift","type":"header-three","key":"as1lf"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Приводим код SIL, сгенерированный для определения класса модели представления:","type":"unstyled","key":"9mdv7"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"class ContentViewModel : ObservableObject {\n @Published @_projectedValueProperty($accounts) var accounts: [Account] { get set _modify }\n var $accounts: Published<[Account]>.Publisher { get set }\n @_hasStorage final var _accounts: Published<[Account]> { get set }\n @Published @_projectedValueProperty($message) var message: String? { get set _modify }\n var $message: Published.Publisher { get set }\n @_hasStorage @_hasInitialValue final var _message: Published { get set }\n @_hasStorage final let loader: AccountLoader { get }\n init(loader: AccountLoader)\n func load() async\n func process(_ accounts: [Account])\n typealias ObjectWillChangePublisher = ObservableObjectPublisher\n @objc deinit\n}","type":"blockquote","key":"9odpf"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"На разбор всего его ушло бы несколько статей, включаю здесь этот код только как основу для последующего сравнения. Здесь имеются обертки свойств и связанные с ними издатели, механизмы хранения значений учетной записи и сообщения и, конечно же, инициализатор, функции load и process, а также сгенерированный псевдоним типа ObjectWillChangePublisher и функция класса deinit.","type":"unstyled","key":"fu4t5"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Это только общее определение класса (кода сгенерировано намного больше), но этих 25 строк Swift достаточно для генерирования 798 строк кода SIL.","type":"unstyled","key":"bbpgv"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Вызов модели представления","type":"header-three","key":"6414k"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Родительским представлением — тоже очень простым — вызывается функция load из модификатора task:","type":"unstyled","key":"dc68o"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"struct ContentView: View {\n @StateObject var viewModel = ContentViewModel(loader: AccountLoader())\n var body: some View {\n Text(\"Number of accounts = \\(viewModel.accounts.count)\")\n .task {\n await viewModel.load()\n }\n }\n}","type":"blockquote","key":"8ihqs"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Код выше рабочий, но при его запуске в симуляторе получим одно из новых фиолетовых сообщений об ошибке Xcode в строках, обозначенных #1 и #2 в исходной модели представления:","type":"unstyled","key":"e9qaf"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"func load() async {\n do {\n accounts = try await loader.load() // #1\n message = nil // #2\n } catch {\n message = \"Unable to load\"\n }\n }","type":"blockquote","key":"5q72q"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":58,"offset":71,"style":"ITALIC"}],"text":"Сообщение: “Publishing changes from background threads is not allowed” («Публикация изменений из фоновых потоков не допускается»).","type":"unstyled","key":"1vkv7"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"При задействовании в асинхронной функции await текущий поток приостанавливается, продолжив выполнение в другом месте. Проблема в том, что задача может возобновиться в другом потоке. И не факт, что в основном.","type":"unstyled","key":"2gt72"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Когда запрошенные учетные записи присваиваются и сообщению задается значение nil, обновляется пользовательский интерфейс. Если в этот момент мы не в основном потоке, получаем ошибку.","type":"unstyled","key":"3gsq2"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Как ее устранить?","type":"unstyled","key":"d66mj"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"MainActor","type":"header-three","key":"684av"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Актор в Swift — это новый примитив многопоточности, которым обеспечивается последовательный доступ к его изменяемому состоянию. В каждый конкретный момент времени доступ или изменение состояния гарантируется только одному фрагменту кода, чем предотвращаются гонки данных и другие баги многопоточности.","type":"unstyled","key":"66gdt"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"MainActor — особая разновидность актора, который также привязан к основному потоку.","type":"unstyled","key":"57oa6"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"А @MainActor — это новая аннотация от Apple для указания Swift, что в коде, который содержится в конкретных классах, функциях или задачах, должен применяться глобальный MainActor и сам код должен всегда выполняться в основном потоке.","type":"unstyled","key":"ddjsn"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Посмотрим, как этим решается обозначенная проблема.","type":"unstyled","key":"63du3"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"MainActor в асинхронной функции","type":"header-three","key":"2g3vr"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Простейшее решение — аннотировать этой @MainActor асинхронную функцию:","type":"unstyled","key":"9g90f"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"class ContentViewModel: ObservableObject {\n ...\n \n @MainActor\n func load() async {\n do {\n accounts = try await loader.load() // #1\n message = nil // #2\n } catch {\n message = \"Unable to load\"\n }\n }\n\n ...\n}","type":"blockquote","key":"55jt1"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":6,"offset":79,"style":"ITALIC"}],"text":"Когда из асинхронной функции загрузчика учетных записей возвращается значение, перед их присвоением Swift при необходимости «запрыгивает» обратно в основной поток.","type":"unstyled","key":"dael0"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Вот определение класса SIL:","type":"unstyled","key":"f01t"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"class ContentViewModel : ObservableObject {\n @Published @_projectedValueProperty($accounts) var accounts: [Account] { get set _modify }\n var $accounts: Published<[Account]>.Publisher { get set }\n @_hasStorage final var _accounts: Published<[Account]> { get set }\n @Published @_projectedValueProperty($message) var message: String? { get set _modify }\n var $message: Published.Publisher { get set }\n @_hasStorage @_hasInitialValue final var _message: Published { get set }\n @_hasStorage final let loader: AccountLoader { get }\n init(loader: AccountLoader)\n @MainActor func load() async\n func process(_ accounts: [Account])\n typealias ObjectWillChangePublisher = ObservableObjectPublisher\n @objc deinit\n}","type":"blockquote","key":"4vahv"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Оно такое же, только функция @MainActor func load() async аннотирована точно так, какой могла быть получена из исходного кода.","type":"unstyled","key":"1b02q"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Покажем также код SIL, сгенерированный для функции load, но не паникуйте. Понадобятся лишь строки, предваряемые комментариями:","type":"unstyled","key":"70qqg"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"sil hidden @$s20ContentViewModelFunc0abC0C4loadyyYaF : $@convention(method) @async (@guaranteed ContentViewModel) -> () {\n// %0 \"self\" // users: %36, %35, %18, %17, %15, %14, %6, %1\nbb0(%0 : $ContentViewModel):\n debug_value %0 : $ContentViewModel, let, name \"self\", argno 1, implicit // id: %1\n // #1 Получаем MainActor\n %2 = metatype $@thick MainActor.Type // user: %4\n // function_ref static MainActor.shared.getter\n %3 = function_ref @$sScM6sharedScMvgZ : $@convention(method) (@thick MainActor.Type) -> @owned MainActor // user: %4\n %4 = apply %3(%2) : $@convention(method) (@thick MainActor.Type) -> @owned MainActor // users: %20, %5, %24, %12\n // #2 Убеждаемся в применении main actor\n hop_to_executor %4 : $MainActor // id: %5\n %6 = ref_element_addr %0 : $ContentViewModel, #ContentViewModel.loader // user: %7\n %7 = load %6 : $*AccountLoader // users: %25, %13, %9, %10, %8\n strong_retain %7 : $AccountLoader // id: %8\n %9 = class_method %7 : $AccountLoader, #AccountLoader.load : (AccountLoader) -> () async throws -> [Account], $@convention(method) @async (@guaranteed AccountLoader) -> (@owned Array, @error Error) // user: %10\n // #3 Вызываем асинхронную функцию\n try_apply %9(%7) : $@convention(method) @async (@guaranteed AccountLoader) -> (@owned Array, @error Error), normal bb1, error bb3 // id: %10\n\n// %11 // user: %15\nbb1(%11 : $Array): // Preds: bb0\n // #4 Убеждаемся в применении main actor\n hop_to_executor %4 : $MainActor // id: %12\n strong_release %7 : $AccountLoader // id: %13\n %14 = class_method %0 : $ContentViewModel, #ContentViewModel.accounts!setter : (ContentViewModel) -> ([Account]) -> (), $@convention(method) (@owned Array, @guaranteed ContentViewModel) -> () // user: %15\n %15 = apply %14(%11, %0) : $@convention(method) (@owned Array, @guaranteed ContentViewModel) -> ()\n %16 = enum $Optional, #Optional.none!enumelt // user: %18\n %17 = class_method %0 : $ContentViewModel, #ContentViewModel.message!setter : (ContentViewModel) -> (String?) -> (), $@convention(method) (@owned Optional, @guaranteed ContentViewModel) -> () // user: %18\n %18 = apply %17(%16, %0) : $@convention(method) (@owned Optional, @guaranteed ContentViewModel) -> ()\n br bb2 // id: %19\n\nbb2: // Preds: bb1 bb3\n strong_release %4 : $MainActor // id: %20\n %21 = tuple () // user: %22\n return %21 : $() // id: %22\n\n// %23 // users: %38, %37, %27, %26\nbb3(%23 : $Error): // Preds: bb0\n // #5 Убеждаемся в применении main actor\n hop_to_executor %4 : $MainActor // id: %24\n strong_release %7 : $AccountLoader // id: %25\n strong_retain %23 : $Error // id: %26\n debug_value %23 : $Error, let, name \"error\", implicit // id: %27\n %28 = string_literal utf8 \"Unable to load\" // user: %33\n %29 = integer_literal $Builtin.Word, 14 // user: %33\n %30 = integer_literal $Builtin.Int1, -1 // user: %33\n %31 = metatype $@thin String.Type // user: %33\n // function_ref String.init(_builtinStringLiteral:utf8CodeUnitCount:isASCII:)\n %32 = function_ref @$sSS21_builtinStringLiteral17utf8CodeUnitCount7isASCIISSBp_BwBi1_tcfC : $@convention(method) (Builtin.RawPointer, Builtin.Word, Builtin.Int1, @thin String.Type) -> @owned String // user: %33\n %33 = apply %32(%28, %29, %30, %31) : $@convention(method) (Builtin.RawPointer, Builtin.Word, Builtin.Int1, @thin String.Type) -> @owned String // user: %34\n %34 = enum $Optional, #Optional.some!enumelt, %33 : $String // user: %36\n %35 = class_method %0 : $ContentViewModel, #ContentViewModel.message!setter : (ContentViewModel) -> (String?) -> (), $@convention(method) (@owned Optional, @guaranteed ContentViewModel) -> () // user: %36\n %36 = apply %35(%34, %0) : $@convention(method) (@owned Optional, @guaranteed ContentViewModel) -> ()\n strong_release %23 : $Error // id: %37\n strong_release %23 : $Error // id: %38\n br bb2 // id: %39\n} // завершаем sil-функцию '$s20ContentViewModelFunc0abC0C4loadyyYaF'","type":"blockquote","key":"8hojn"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":10,"offset":79,"style":"ITALIC"},{"length":10,"offset":108,"style":"ITALIC"}],"text":"Под комментарием #1 видим строки кода для получения ссылки на глобальный класс main actor и общий экземпляр main actor, используемый во всем приложении.","type":"unstyled","key":"fqqlo"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Все волшебство — в инструкции под комментарием #2 hop_to_executor %4 : $MainActor: ею вызывается метод для возвращения к основному потоку, если мы еще не в нем.","type":"unstyled","key":"228g4"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":10,"offset":5,"style":"ITALIC"}],"text":"Если main actor занят и используется кем-то другим, задача снова приостанавливается.","type":"unstyled","key":"3fib3"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Под комментарием #3 выполняется асинхронный вызов загрузчика учетной записи для получения данных. Обратите внимание на normal bb1, error bb3 в вызове функции: так коду фактически указывается, куда переходить при нормальном возвращении функции или выбрасывании ошибки.","type":"unstyled","key":"8fga1"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Под комментариями #4 и #5 снова вызывается hop_to_executor: возвращаемся к основному потоку, прежде чем что-то присваивать издателям.","type":"unstyled","key":"efmpq"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":7,"offset":21,"style":"ITALIC"}],"text":"Так происходит после каждого вызова await в функции: оцениваем правую часть, запрыгиваем в основной поток, присваиваем.","type":"unstyled","key":"9vt7f"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Удивительно, что при добавлении аннотации @MainActor к функции исходный код увеличился на одну строку, а общий сгенерированный размер — лишь до 805 строк кода SIL, то есть общее увеличение < 1 %.","type":"unstyled","key":"2agq8"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Механизм довольно эффективен.","type":"unstyled","key":"3noj"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"MainActor в классе","type":"header-three","key":"c8hs3"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Альтернатива ему — аннотирование всего класса @MainActor:","type":"unstyled","key":"earfb"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"@MainActor\nclass ContentViewModel: ObservableObject {\n ...\n}","type":"blockquote","key":"5r6lr"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":10,"offset":147,"style":"ITALIC"}],"text":"Так указываем Swift, что, в дополнение к асинхронному поведению выше, каждый вызов каждой функции и каждая ссылка на свойство должны выполняться в main actor.","type":"unstyled","key":"36mvh"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Это отлично иллюстрируется общим кодом SIL, созданным для определения класса:","type":"unstyled","key":"377ru"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"@MainActor class ContentViewModel : ObservableObject {\n @Published @_projectedValueProperty($accounts) @MainActor var accounts: [Account] { get set _modify }\n @MainActor var $accounts: Published<[Account]>.Publisher { get set }\n @_hasStorage @MainActor final var _accounts: Published<[Account]> { get set }\n @Published @_projectedValueProperty($message) @MainActor var message: String? { get set _modify }\n @MainActor var $message: Published.Publisher { get set }\n @_hasStorage @_hasInitialValue @MainActor final var _message: Published { get set }\n @_hasStorage @MainActor final let loader: AccountLoader { get }\n @MainActor init(loader: AccountLoader)\n @MainActor func load() async\n @MainActor func process(_ accounts: [Account])\n typealias ObjectWillChangePublisher = ObservableObjectPublisher\n @objc deinit\n}","type":"blockquote","key":"7ehfe"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":3,"offset":45,"style":"ITALIC"}],"text":"Здесь в Swift наши указания выполнены, почти все в классе помечено @MainActor.","type":"unstyled","key":"35jj4"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":9,"offset":42,"style":"ITALIC"}],"text":"Еще сюрприз: размер сгенерированного кода идентичен первой версии с асинхронной функцией, то есть всего 26 строк исходного кода и 805 строк кода SIL.","type":"unstyled","key":"dak91"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":80,"offset":0,"style":"ITALIC"}],"text":"Добавление в класс main actor практически не сказалось на остальном коде класса.","type":"unstyled","key":"9a8q0"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Значит, просто помечаем так весь класс — и проблема решена?","type":"unstyled","key":"2k9h0"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":3,"offset":23,"style":"ITALIC"},{"length":15,"offset":100,"style":"ITALIC"},{"length":6,"offset":128,"style":"ITALIC"},{"length":5,"offset":220,"style":"ITALIC"},{"length":10,"offset":270,"style":"ITALIC"}],"text":"Вряд ли. То, что почти все классе помечено как @MainActor, чревато побочными эффектами и проблемами в других местах кода. Любой другой класс или метод, чтобы получить доступ к одной из переменных или методов экземпляра, также должен находиться в изолированном контексте main actor.","type":"unstyled","key":"bis62"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Или в изолированном контексте с применением await для ссылки на значение.","type":"unstyled","key":"ehufo"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Обычно это не проблема, если к модели представления имеется доступ из SwiftUI: представления SwiftUI и body представлений тоже помечаются как @MainActor.","type":"unstyled","key":"fpr6k"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Трудности появляются, если модель представления создается или используется из неизолированного контекста: из системы внедрения зависимостей, другого метода в кодовой базе или даже модульного теста.","type":"unstyled","key":"9aths"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":3,"offset":29,"style":"ITALIC"},{"length":3,"offset":99,"style":"ITALIC"},{"length":10,"offset":142,"style":"ITALIC"}],"text":"Обычное решение — помечать эти методы как @MainActor — чревато проблемами с методами, которыми они вызываются, и заполонением аннотациями main actor всей кодовой базы.","type":"unstyled","key":"b7u0h"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":10,"offset":61,"style":"ITALIC"}],"text":"Этим все усложняется. По-моему, проще функции, которым нужен main actor, пометить как @MainActor — и проблема решится.","type":"unstyled","key":"65dr6"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"С этим прицелом рассмотрим следующий пример.","type":"unstyled","key":"ehh46"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"MainActor в функциях обновления","type":"header-three","key":"cg7sa"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":10,"offset":73,"style":"ITALIC"}],"text":"Другое решение — создание функций обновления, аннотированных с помощью main actor:","type":"unstyled","key":"9405h"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"class ContentViewModel: ObservableObject {\n\n @Published var accounts: [Account]\n @Published var message: String?\n\n let loader: AccountLoader\n\n init(loader: AccountLoader) {\n self.accounts = []\n self.loader = loader\n }\n\n func load() async {\n do {\n let accounts = try await loader.load()\n await process(accounts) // #3\n } catch {\n await message(\"Unable to load\") // #4\n }\n }\n\n @MainActor // #1\n func process(_ accounts: [Account]) {\n self.accounts = accounts\n }\n\n @MainActor // #2\n func message(_ message: String) {\n self.message = message\n }\n}","type":"blockquote","key":"3qa1g"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":10,"offset":13,"style":"ITALIC"}],"text":"Аннотирована main actor теперь не функция load, а измененная process (#1) и добавленная функция обновления сообщений (#2). При необходимости они вызываются из функции load (#3 и #4).","type":"unstyled","key":"40jsn"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":5,"offset":55,"style":"ITALIC"},{"length":2,"offset":86,"style":"ITALIC"}],"text":"Это часто бывает, когда нужна дополнительная обработка после вызова функции await, но до присвоения классам свойств экземпляра и эта обработка в основном потоке не желательна.","type":"unstyled","key":"47l50"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":10,"offset":102,"style":"ITALIC"}],"text":"Функцию load не помечают как @MainActor — сделав работу, переходят к другой функции, помеченной как main actor, для выполнения фактических обновлений пользовательского интерфейса.","type":"unstyled","key":"f7pa5"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Но такой подход проблематичен по двум причинам.","type":"unstyled","key":"2qkhh"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Во-первых, на 20%, до 31 строки, увеличился исходный код, а сгенерированный код SIL — до 831.","type":"unstyled","key":"dl760"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":10,"offset":83,"style":"ITALIC"}],"text":"Этот рост обусловлен созданием и/или изменением функций обновления с дублированным main actor, а также теперь уже переходом функции load из неизолированного контекста в изолированный. Вернувшись к комментариям #3 и #4, вы увидите: теперь для вызова процедур обновления нужна и await.","type":"unstyled","key":"6gi7t"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Вторая загвоздка круче. Мы знаем, что при возвращении из await попадание в основной поток не гарантировано, и делаем свою работу.","type":"unstyled","key":"58p8v"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":68,"offset":27,"style":"ITALIC"},{"length":2,"offset":70,"style":"BOLD"}],"text":"Впрочем, верно и обратное: в системе не прописано конкретной гарантии непопадания в этот поток.","type":"unstyled","key":"bd3vu"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Подумайте немного об этом.","type":"unstyled","key":"3te4b"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":4,"offset":156,"style":"ITALIC"}],"text":"Если нужно много обработки вне основного потока, стоит так ее и выполнить явно. Решения описываемой проблемы выходят за рамки статьи. Просто имейте в виду: этим конкретным подходом можно и не достичь того, что представляется достижимым.","type":"unstyled","key":"ftijc"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"MainActor.run","type":"header-three","key":"bp9qo"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Другое решение заключается в явном, самостоятельном возвращении к основному потоку с помощью MainActor.run. Вот функция load:","type":"unstyled","key":"e135v"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"func load() async {\n do {\n let accounts = try await loader.load()\n await MainActor.run {\n self.accounts = accounts\n message = nil\n }\n } catch {\n await MainActor.run {\n message = \"Unable to load\"\n }\n }\n }","type":"blockquote","key":"a8mqf"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Кажется относительно чистой, но при ее выполнении генерируется заметно больше кода — исходный увеличивается до 30 строк, а сгенерированный SIL — до 918, то есть на 15%.","type":"unstyled","key":"2udla"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Почему? Мы же просто делаем то, что уже делается в компиляторе Swift.","type":"unstyled","key":"opbd"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":4,"offset":156,"style":"ITALIC"}],"text":"Да, но мы не компилятор Swift. Увеличение сгенерированного кода для этого и двух оставшихся решений — взрывное, поскольку двум обработчикам MainActor.run тоже нужно генерировать код для создания и выделения новых замыканий для основных блоков обновления и ошибок, а этим замыканиям нужно захватывать значения из текущего контекста и т. д.","type":"unstyled","key":"786oi"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Код SIL для этого решения в статью не включен: он занимает пару страниц, и я бы все равно от него отказался.","type":"unstyled","key":"67qc8"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Task/MainActor","type":"header-three","key":"9q0hh"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Это тоже типичный подход:","type":"unstyled","key":"3c7dn"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"func load() async {\n do {\n let accounts = try await loader.load()\n Task { @MainActor in\n self.accounts = accounts\n message = nil\n }\n } catch {\n Task { @MainActor in\n message = \"Unable to load\"\n }\n }\n }","type":"blockquote","key":"5mrpl"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Те же 30 строк исходного кода, но SIL увеличивается до 935.","type":"unstyled","key":"sani"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Часть проблемы заключается в том, что, как и в MainActor.run, для выполнения обновлений создаются новые замыкания task.","type":"unstyled","key":"20g7i"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":2,"offset":214,"style":"ITALIC"}],"text":"Другая проблема серьезнее: для выполнения обновления создается новый task, выполняемый асинхронно или в зависимости от нагрузки с ожиданием завершения другой работы. В обоих случаях имеющаяся функция load вернется до обновления опубликованных значений.","type":"unstyled","key":"ddqk"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Добавив пару операторов print, увидим это:","type":"unstyled","key":"aqo1j"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"func load() async {\n do {\n let accounts = try await loader.load()\n Task { @MainActor in\n print(\"updating\")\n self.accounts = accounts\n message = nil\n }\n print(\"returning\")\n } catch {\n Task { @MainActor in\n message = \"Unable to load\"\n }\n }\n }","type":"blockquote","key":"dgrkg"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":11,"offset":34,"style":"ITALIC"},{"length":5,"offset":47,"style":"ITALIC"},{"length":14,"offset":64,"style":"ITALIC"}],"text":"Запускаем код и видим ”returning“ («Возврат»), затем “updating” («Обновление»).","type":"unstyled","key":"a2shv"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":4,"offset":18,"style":"ITALIC"}],"text":"Задержка, которой чуть затрудняется написание тестового кода.","type":"unstyled","key":"1m1a"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"DispatchQueue.main","type":"header-three","key":"fpj7s"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Последний подход — отказ от предыдущих. По сути, мы полностью уходим от многопоточности Swift и возвращаемся к DispatchQueue.main:","type":"unstyled","key":"9l5h8"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"func load() async {\n do {\n let accounts = try await loader.load()\n DispatchQueue.main.async {\n self.accounts = accounts\n self.message = nil\n }\n } catch {\n DispatchQueue.main.async {\n self.message = \"Unable to load\"\n }\n }\n }","type":"blockquote","key":"1b2k4"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":8,"offset":4,"style":"ITALIC"},{"length":4,"offset":154,"style":"ITALIC"}],"text":"Это возможно, но все недостатки двух предыдущих решений остаются. По размеру сгенерированного кода — 933 строки — оно практически идентично механизму Task, и обновление наверняка принудительно выполнится асинхронно.","type":"unstyled","key":"b599g"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Не опускайте рук из-за уже обозначенных проблем, например трудностей при тестировании, а стремитесь к цели.","type":"unstyled","key":"e5lhg"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Заключение","type":"header-three","key":"2uv6u"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Это все на сегодня. Мой выбор — первый пример с аннотированием асинхронной функции или функций, которые нужно аннотировать и где выполняются обновления потоков пользовательского интерфейса:","type":"unstyled","key":"chtmo"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"class ContentViewModel: ObservableObject {\n ...\n \n @MainActor\n func load() async {\n do {\n accounts = try await loader.load() // #1\n message = nil // #2\n } catch {\n message = \"Unable to load\"\n }\n }\n\n ...\n}","type":"blockquote","key":"cbhi8"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Все показанные здесь стратегии рабочие, но если придерживаться этого подхода, кода будет меньше. Он самый простой, работает эффективнее, в нем генерируется меньше кода и меньше побочных эффектов.","type":"unstyled","key":"eli4b"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Какой выберете вы?","type":"unstyled","key":"6ijv8"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Читайте также:","type":"unstyled","key":"dipeo"},{"data":{},"depth":0,"entityRanges":[{"key":1,"length":37,"offset":0}],"inlineStyleRanges":[],"text":"Реактивное программирование с Combine","type":"unordered-list-item","key":"3j7gj"},{"data":{},"depth":0,"entityRanges":[{"key":2,"length":51,"offset":0}],"inlineStyleRanges":[],"text":"Как освоить API-интерфейсы Metal с UIView и SwiftUI","type":"unordered-list-item","key":"lc4d"},{"data":{},"depth":0,"entityRanges":[{"key":3,"length":31,"offset":0}],"inlineStyleRanges":[],"text":"Диспетчеризация методов в Swift","type":"unordered-list-item","key":"82b6f"},{"data":{},"depth":0,"entityRanges":[{"key":4,"length":8,"offset":14},{"key":5,"length":2,"offset":24}],"inlineStyleRanges":[],"text":"Читайте нас в Telegram, VK","type":"unstyled","key":"14dpn"},{"data":{},"depth":0,"entityRanges":[{"key":6,"length":12,"offset":15},{"key":7,"length":36,"offset":29}],"inlineStyleRanges":[{"length":15,"offset":0,"style":"ITALIC"}],"text":"Перевод статьи Michael Long: Async/Await and MainActor Strategies","type":"unstyled","key":"a4skh"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"unstyled","key":"1jj59"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"marker","key":"i82ZFaMdzOKRV3B6WMSD"}],"entityMap":{"0":{"data":{"url":"https://nuancesprog.ru/p/18031/"},"mutability":"MUTABLE","type":"LINK"},"1":{"data":{"href":"https://nuancesprog.ru/p/17799/","url":"https://nuancesprog.ru/p/17799/"},"mutability":"MUTABLE","type":"LINK"},"2":{"data":{"href":"https://nuancesprog.ru/p/17600/","url":"https://nuancesprog.ru/p/17600/"},"mutability":"MUTABLE","type":"LINK"},"3":{"data":{"href":"https://nuancesprog.ru/p/17088/","url":"https://nuancesprog.ru/p/17088/"},"mutability":"MUTABLE","type":"LINK"},"4":{"data":{"href":"https://t.me/nuancesprog","url":"https://t.me/nuancesprog"},"mutability":"MUTABLE","type":"LINK"},"5":{"data":{"href":"https://vk.com/nuancesprog","url":"https://vk.com/nuancesprog"},"mutability":"MUTABLE","type":"LINK"},"6":{"data":{"href":"https://michaellong.medium.com/?source=post_page-----cc35b6c58b52--------------------------------","url":"https://michaellong.medium.com/?source=post_page-----cc35b6c58b52--------------------------------"},"mutability":"MUTABLE","type":"LINK"},"7":{"data":{"href":"https://betterprogramming.pub/async-await-and-mainactor-strategies-cc35b6c58b52","url":"https://betterprogramming.pub/async-await-and-mainactor-strategies-cc35b6c58b52"},"mutability":"MUTABLE","type":"LINK"}}},"mentions":[]}