Post not yet marked as solved
Hi everyone,
I'm trying to make use of a background actor in my SwiftUI project. Inserting data works with the ModelContainer's mainContext. Another context in a ModelActor, however, fails to write into the same database.
I verify the results by opening the SQLite file on the file system. While the mainContext.insert call does indeed insert a row into the table, the ModelActor's context fails to do so.
There is no error or message received in the ModelActor. The property autosaveEnabled is set to true.
I wrote a sample project to reproduce the issue in isolation. It consists of a single source file that introduces the Model ToDo, the ToDoView, initializes the ModelContainer and ModelActor. Please find the source code below.
Is there any mistake in my approach?
import SwiftUI
import SwiftData
@Model
final class ToDo {
let title: String
init(title: String) {
self.title = title
}
}
@main
struct testSwiftDataApp: App {
@State
var modelContainer: ModelContainer
@State
var backgroundData: BackgroundDataActor
init() {
let modelContainer: ModelContainer =
try! ModelContainer(for: ToDo.self)
self.modelContainer = modelContainer
self.backgroundData = BackgroundDataActor(
modelContainer: modelContainer
)
}
var body: some Scene {
WindowGroup {
ToDoView(backgroundData: self.backgroundData)
.modelContainer(modelContainer)
}
}
}
struct ToDoView: View {
@Environment(\.modelContext)
var modelContext
@Query
var todos: [ToDo]
let backgroundData: BackgroundDataActor
var modelContainer: ModelContainer {
self.modelContext.container
}
var body: some View {
VStack {
Text("Add ToDo")
TextField(
"",
text: .constant(
"URL to database: " +
"\(self.modelContainer.configurations.first!.url)"
)
)
// This action will be invoked on the ModelActor's context
Button {
Task {
let todo = ToDo(title: "Step 1")
await self.backgroundData.store(
id: todo.persistentModelID
)
}
} label: {
Text("Create ToDo in background")
}
// This action will be invoked on the mainContext
Button {
Task {
let todo = ToDo(title: "Step 2")
self.modelContainer.mainContext.insert(todo)
}
} label: {
Text("Create ToDo in foreground")
}
// Show the query results
VStack {
Text("Available ToDos")
ForEach(self.todos) {
Text($0.title)
}
}
}
}
}
@ModelActor
actor BackgroundDataActor: ModelActor {
func store(id: PersistentIdentifier) {
print("Trying to save")
print("Is auto save enabled: \(self.modelContext.autosaveEnabled)")
if let dbo = self[id, as: ToDo.self] {
self.modelContext.insert(dbo)
try! self.modelContext.save()
print("Saved into database")
}
}
}
Post not yet marked as solved
Hello. I have the following question. I call the nextBatch() method on MusicItemCollection to get the next collection of artist albums. Here is my method:
func allAlbums2(artist: Artist) async throws -> [Album] {
var allAlbums: [Album] = []
artist.albums?.forEach { allAlbums.append($0) }
guard let albums = artist.albums else { return [] }
var albumsCollection = albums
while albumsCollection.hasNextBatch {
let response = try await albumsCollection.nextBatch()
if let response {
albumsCollection = response
var albums = [Album]()
albumsCollection.forEach({ albums.append($0)})
allAlbums.append(contentsOf: albums)
}
}
return allAlbums
}
The problem is as follows. Sometimes it happens that some albums not in nextBatch are not returned (I noticed one, I didn't check the others). This happens once every 50-100 requests. The number of batches is returned the same when the album is skipped. The same albums are returned in the batch where the album was missed. I have a question, do I have a problem with multi-threading or something else or is it a problem in the API. The file contains prints of the returned batches. One with a missing album, the other without a missing one. There are about 3000 lines in the file. I will be grateful for a hint or an answer. Thank you!
Here link to file: https://files.fm/u/nj4r5wgyg3
Post not yet marked as solved
OSAllocatedUnfairLock has two different methods for executing a block of code with the lock held: withLock() and withLockUnchecked(). The only difference between the two is that the former has the closure and return type marked as Sendable. withLockUnchecked() has a comment (that is for reasons I do not understand not visible in the documentation) saying:
/// This method does not enforce sendability requirement
/// on closure body and its return type.
/// The caller of this method is responsible for ensuring references
/// to non-sendables from closure uphold the Sendability contract.
What I do not understand here is why Sendable conformance would be needed. These function should call this block synchronously in the same context, and return the return value through a normal function return. None of this should require the types to be Sendable. This seems to be supported by this paragraph of the documentation for OSAllocatedUnfairLock:
/// This lock must be unlocked from the same thread that locked it. As such, it
/// is unsafe to use `lock()` / `unlock()` across an `await` suspension point.
/// Instead, use `withLock` to enforce that the lock is only held within
/// a synchronous scope.
So, why does this Sendable requirement exist, and in practice, if I did want to use withLockUnchecked, how would I "uphold the Sendability contract"?
To summarise the question in a more concise way: Is there an example where using withLockUnchecked() would actually cause a problem, and using withLock() instead would catch that problem?
Post not yet marked as solved
I’m working on updating one of my apps to the asynchronous location updates API, but have been running into an unhelpful error.
Here's my code:
@Observable
class CurrentLocation: NSObject, CLLocationManagerDelegate {
private(set) var location: CLLocation?
private let locationManager = CLLocationManager()
override init() {
super.init()
self.locationManager.delegate = self
self.locationManager.desiredAccuracy = kCLLocationAccuracyReduced
}
func requestLocation() async throws {
print("requesting location")
requestAccess()
for try await update in CLLocationUpdate.liveUpdates() {
self.location = update.location
if update.isStationary {
break
}
}
}
}
But after calling requestLocation(), I receive the following error in the console without any location updates:
{"msg":"#locationUpdater received unhandled message", "Message":kCLConnectionMessageCompensatedLocation, "self":"0x600002eaa600"}
Googling this error yields absolutely no matches. I’ve ensured that I have the necessary Info.plist entries (as the old, synchronous location update code I have is also working without issues). I’d be grateful for any assistance!
Post not yet marked as solved
I am trying to sync the ntp time from the server using Kronos library.
However, I believe the code is not fully protected from multithreading access since it is using low level system code.
So, does anyone know how can I ensure sysctl and gettimeofday are thread-safe when calling them? Or, is there any thread-safe alternative to get the same result?
func currentTime() -> TimeInterval {
var current = timeval()
let systemTimeError = gettimeofday(&current, nil) != 0
assert(!systemTimeError, "system clock error: system time unavailable")
return Double(current.tv_sec) + Double(current.tv_usec) / 1_000_000
}
static func systemUptime() -> TimeInterval {
var mib = [CTL_KERN, KERN_BOOTTIME]
var size = MemoryLayout<timeval>.stride
var bootTime = timeval()
let bootTimeError = sysctl(&mib, u_int(mib.count), &bootTime, &size, nil, 0) != 0
assert(!bootTimeError, "system clock error: kernel boot time unavailable")
let now = currentTime()
let uptime = Double(bootTime.tv_sec) + Double(bootTime.tv_usec) / 1_000_000
assert(now >= uptime, "inconsistent clock state: system time precedes boot time")
return now - uptime
}
I have thought of using NSLock but I can only protect from the getter (caller) not the setter (system)
Post not yet marked as solved
Hi, just trying to learn how to work with mainActor. I am in a need of analyzing users data with API service one a background. Whenever user saves a post into SwiftData, I need to analyze that posts asynchronously. Here is my current code, which by the way works, but I am getting warning here;
actor DatabaseInteractor {
let networkInteractor: any NetworkInteractor = NetworkInteractorImpl()
func loadUserProfile() async -> String {
do {
let objects = try await modelContainer.mainContext.fetch(FetchDescriptor<ProfileSwiftData>())
if let profileTest = objects.first?.profile {
return profileTest
}
} catch {
}
return ""
}
I get a warning on let objects line.
Warning: Non-sendable type 'ModelContext' in implicitly asynchronous access to main actor-isolated property 'mainContext' cannot cross actor boundary
Post not yet marked as solved
Previously, it was recommended to use the @MainActor annotation for ObservableObject implementation.
@MainActor
final class MyModel: ObservableObject {
let session: URLSession
@Published var someText = ""
init(session: URLSession) {
self.session = session
}
}
We could use this as either a @StateObject or @ObservedObject:
struct MyView: View {
@StateObject let model = MyModel(session: .shared)
}
By moving to Observation, I need to the @Observable macro, remove the @Published property wrappers and Switch @StateObject to @State:
@MainActor
@Observable
final class MyModel {
let session: URLSession
var someText = ""
init(session: URLSession) {
self.session = session
}
}
But switching from @StateObject to @State triggers me an error due to a call to main-actor isolated initialiser in a synchronous nonisolated context.
This was not the case with @StateObject of @ObservedObject.
To suppress the warning I could :
mark the initializer as nonisolated but it is not actually what I want
Mark the View with @MainActor but this sounds odd
Both solutions does not sound nice to my eye.
Did I miss something here?
The following Swift UIKit code produces the warning "Cannot access property 'authController' with a non-sendable type 'AuthController' from non-isolated deinit; this is an error in Swift 6":
import UIKit
class AuthFormNavC: UINavigationController {
let authController: AuthController
init(authController: AuthController) {
self.authController = authController
super.init(rootViewController: ConsentVC())
}
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
deinit {
authController.signInAnonymouslyIfNecessary()
}
}
Swift 5.10, Xcode 15.3 with complete strict concurrency checking.
What is the workaround?
Please don't ask me why I'm doing what I'm doing or anything unrelated to the question.
If you're wondering why I want to call authController.signInAnonymouslyIfNecessary() when the navigation controller is denitialized, my goal is to call it when the navigation controller is dismissed (or popped), and I think that the deinitializer of a view controller is the only method that is called if and only if the view controller is being dismissed (or popped) in my case. I tried observing variables like isViewLoaded in the past using KVO but I couldn't get it to work passing any combination of options in observe(_:options:changeHandler:).
Post not yet marked as solved
Hi! I'm running into a warning from a SwiftUI.DynamicProperty on a 6.0 development build (swift-6.0-DEVELOPMENT-SNAPSHOT-2024-03-26-a).
I am attempting to build a type (conforming to DynamicProperty) that should also be MainActor. This type with also need a custom update function. Here is a simple custom wrapper (handwaving over the orthogonal missing pieces) that shows the warning:
import SwiftUI
@MainActor struct MainProperty: DynamicProperty {
// Main actor-isolated instance method 'update()' cannot be used to satisfy nonisolated protocol requirement; this is an error in the Swift 6 language mode
@MainActor func update() {
}
}
Is there anything I can do about that warning? Does the warning correctly imply that this will be a legit compiler error when 6.0 ships?
I can find (at least) two examples of types adopting DynamicProperty from Apple that are also MainActor: FetchRequest and SectionedFetchRequest. What is confusing is that both FetchRequest^1 and SectionedFetchRequest^2 explicitly declare their update method to be MainActor. Is there anything missing from my Wrapper declaration that can get me what I'm looking for? Any more advice about that? Thanks!
Post not yet marked as solved
I'm trying to reproduce a case when there are more dispatch queues than there are threads serving them. Is that a possible scenario?
Post not yet marked as solved
I am working on a similar application and would like to refer to the sample application referred in this video - "File Squeezer" and couldn't find anywhere. Could anybody please help me find this sample code?
Post not yet marked as solved
I've just updated to Xcode 15.3 and iOS 17.4 (simulator). Every time I launch the app, I see a CPU spike keeping the CPU at 100% for about 30 seconds on a background thread. After those 30 seconds, there's a 'Thread Performance Checker' error posted on the console.
This does not happen when using Xcode 15.2 and running on iOS 17.2. or iOS 16.4.
Thread Performance Checker: Thread running at User-initiated quality-of-service class waiting on a thread without a QoS class specified (base priority 33). Investigate ways to avoid priority inversions
PID: 70633, TID: 2132693
Backtrace
=================================================================
3 CFNetwork 0x000000018454094c estimatedPropertyListSize + 28648
4 CFNetwork 0x00000001843d7fc0 cfnTranslateCFError + 1864
5 libdispatch.dylib 0x000000010557173c _dispatch_client_callout + 16
6 libdispatch.dylib 0x0000000105573210 _dispatch_once_callout + 84
7 CFNetwork 0x00000001843d7f8c cfnTranslateCFError + 1812
8 CFNetwork 0x0000000184540814 estimatedPropertyListSize + 28336
9 libdispatch.dylib 0x000000010557173c _dispatch_client_callout + 16
10 libdispatch.dylib 0x0000000105573210 _dispatch_once_callout + 84
11 CFNetwork 0x0000000184540728 estimatedPropertyListSize + 28100
12 CFNetwork 0x0000000184540794 estimatedPropertyListSize + 28208
13 libdispatch.dylib 0x000000010557173c _dispatch_client_callout + 16
14 libdispatch.dylib 0x0000000105573210 _dispatch_once_callout + 84
15 CFNetwork 0x0000000184540780 estimatedPropertyListSize + 28188
16 CFNetwork 0x00000001844e8664 _CFNetworkHTTPConnectionCacheSetLimit + 191584
17 CFNetwork 0x00000001844e78dc _CFNetworkHTTPConnectionCacheSetLimit + 188120
18 CFNetwork 0x000000018439ce5c _CFURLCachePersistMemoryToDiskNow + 25460
19 CFNetwork 0x0000000184483068 _CFStreamErrorFromCFError + 609680
20 CFNetwork 0x000000018445105c _CFStreamErrorFromCFError + 404868
21 CFNetwork 0x000000018443a040 _CFStreamErrorFromCFError + 310632
22 CFNetwork 0x000000018453be14 estimatedPropertyListSize + 9392
23 CFNetwork 0x000000018440fa5c _CFStreamErrorFromCFError + 137092
26 CFNetwork 0x000000018445b398 _CFStreamErrorFromCFError + 446656
27 CFNetwork 0x0000000184459db8 _CFStreamErrorFromCFError + 441056
28 CFNetwork 0x000000018445cf60 _CFStreamErrorFromCFError + 453768
29 CFNetwork 0x0000000184541838 estimatedPropertyListSize + 32468
30 libdispatch.dylib 0x000000010556fec4 _dispatch_call_block_and_release + 24
31 libdispatch.dylib 0x000000010557173c _dispatch_client_callout + 16
32 libdispatch.dylib 0x0000000105579a30 _dispatch_lane_serial_drain + 916
33 libdispatch.dylib 0x000000010557a774 _dispatch_lane_invoke + 420
34 libdispatch.dylib 0x000000010557b6e4 _dispatch_workloop_invoke + 864
35 libdispatch.dylib 0x00000001055871a8 _dispatch_root_queue_drain_deferred_wlh + 324
36 libdispatch.dylib 0x0000000105586604 _dispatch_workloop_worker_thread + 488
37 libsystem_pthread.dylib 0x0000000106b87924 _pthread_wqthread + 284
38 libsystem_pthread.dylib 0x0000000106b866e4 start_wqthread + 8
Post not yet marked as solved
I have an async function where im using the withUnsafeContinuation method and closure but for some reason Xcode is not letting me pass either 'error' or 'Error' for continuation.resume(throwing:). I get the error "Cannot convert value of type 'any Error'"
public func parseResponseData(data: Data) async throws -&gt; TextResult {
return try await withUnsafeContinuation { continuation in
Task {
do {
let decoder = JSONDecoder()
let result = try await decoder.decode(TextResult.self, from: data)
continuation.resume(returning: result)
} catch {
continuation.resume(throwing: error)
}
}
}
}
Post not yet marked as solved
Hello, I am trying to debug Swift Concurrency codes by using Swift Concurrency Instruments.
But in our project which has been maintained for a long time, Swift Concurrency Instruments seems not working.
Task {
print("async code")
await someAsyncFunction()
}
When I run Swift Concurrency Instruments with the above codes in our project, I could check that the print works well by checking stdout/stderr Instruments, but there are no records on Swift Concurrency Instruments.
But in the small simple sample project, I checked that Swift Concurrency Instruments works well.
Are there any settings that I need to do for the legacy project to debug Swift Concurrency?
Hi,
Given pthread_id (†), is there a way to find the associated NSThread (when the one exists)? Perhaps using an undocumented / unsupported method – I don't mind.
Thank you!
(†) the pthread_id is neither of the current nor of the main thread.
Hello,
im currently rewriting my entire network stuff to swift concurrency. I have a Swift Package which contains the NWConnection with my custom framing protocol. So Network framework does not support itself concurrency so I build an api around that. To receive messages I used an AsyncThrowingStream and it works like that:
let connection = MyNetworkFramework(host: "example.org")
Task {
await connection.start()
for try await result in connection.receive() {
// do something with result
}
}
that's pretty neat and I like it a lot but now things got tricky. in my application I have up to 10 different tcp streams I open up to handle connection stuff. so with my api change every tcp connection runs in it's own task like above and I have no idea how to handle the possible errors from the .receive() func inside the tasks.
First my idea was to use a ThrowingTaskGroup for that and I think that will work but biggest problem is that I initially start with let's say 4 tcp connections and I need the ability to add additional ones later if I need them. so it seems not possible to add a Task afterwards to the ThrowingTaskGroup.
So what's a good way to handle a case like that?
i have an actor which handles everything in it's isolated context and basically I just need let the start func throw if any of the Tasks throw I open up. Here is a basic sample of how it's structured.
Thanks Vinz
internal actor MultiConnector {
internal var count: Int { connections.count }
private var connections: [ConnectionsModel] = []
private let host: String
private let port: UInt16
private let parameters: NWParameters
internal init(host: String, port: UInt16, parameters: NWParameters) {
self.host = host
self.port = port
self.parameters = parameters
}
internal func start(count: Int) async throws -> Void {
guard connections.isEmpty else { return }
guard count > .zero else { return }
try await sockets(from: count)
}
internal func cancel() -> Void {
guard !connections.isEmpty else { return }
for connection in connections { connection.connection.cancel() }
connections.removeAll()
}
internal func sockets(from count: Int) async throws -> Void {
while connections.count < count { try await connect() }
}
}
// MARK: - Private API -
private extension MultiConnector {
private func connect() async throws -> Void {
let uuid = UUID(), connection = MyNetworkFramework(host: host, port: port, parameters: parameters)
connections.append(.init(id: uuid, connection: connection))
let task = Task { [weak self] in guard let self else { return }; try await stream(connection: connection, id: uuid) }
try await connection.start(); await connection.send(message: "Sample Message")
// try await task.value <-- this does not work because stream runs infinite until i cancel it (that's expected and intended but it need to handle if the stream throws an error)
}
private func stream(connection: MyNetworkFramework, id: UUID) async throws -> Void {
for try await result in connection.receive() {
if case .message(_) = result { await connection.send(message: "Sample Message") }
// ... more to handle
}
}
}
Post not yet marked as solved
I'm hoping someone can help me understand some unexpected behavior in a @MainActor Function which internally calls a task that calls a method on a background actor.
Normally, the function would call the task, pause until the task completes, and finish the end of the function.
However, when the function is annotated @Main actor, the internal task appears to become detached and execute asynchronously such that it finishes after the @MainActor function.
The code below demonstrates this behavior in a playground:
actor SeparateActor{
func actorFunc(_ str:String){
print("\tActorFunc(\(str))")
}
}
class MyClass{
var sa = SeparateActor()
@MainActor func mainActorFunctionWithTask(){
print("mainActorFunctionWithTask Start")
Task{
await self.sa.actorFunc("mainActorFunctionWithTask")
}
print("mainActorFunctionWithTask End")
}
func normalFuncWithTask(){
print("normalFuncWithTask Start")
Task{
await self.sa.actorFunc("normalFuncWithTask")
}
print("normalFuncWithTask End")
}
}
Task{
let mc = MyClass()
print("\nCalling normalFuncWithTask")
mc.normalFuncWithTask()
print("\nCalling mainActorFunctionWithTask")
await mc.mainActorFunctionWithTask()
}
I would expect both the normalFunc and the mainActorFunc to behave the same, with the ActorFunc being called before the end of the task, but instead, my mainActor function completes before the task.
Calling normalFuncWithTask
normalFuncWithTask Start
ActorFunc(normalFuncWithTask)
normalFuncWithTask End
Calling mainActorFunctionWithTask
mainActorFunctionWithTask Start
mainActorFunctionWithTask End
ActorFunc(mainActorFunctionWithTask)
I run the following code in an actor:
func aaa() async throws -> Data {
async let result = Task(
operation: {
... decompressing data through try (data as NSData).decompressed(using: .lzfse) as Data
}
).result
switch await result {
case .success(let value): return value
case .failure(let error): throw error
}
I do it this way because I do not want to block the actor by decompression, and there is no state change in the actor afterwards. I would say that the actor plays no significant role here. Important is that many (14) concurrent tasks run in parallel, however NOT on the same data. It runs fine for a while (dozens/hundreds of data decompressed), and then the following happens:
Activity Monitor (macOS GUI tool) shows almost none User CPU time, and approx. 75% System CPU time. The rest is idle. (When it runs fine, User CPU time is 95+%)
When I pause the run in Xcode (in release config it behaves the same), all threads are in mach_msg2_trap
#0 0x0000000180ac21f4 in mach_msg2_trap ()
#1 0x0000000180ad4b24 in mach_msg2_internal ()
#2 0x0000000180ac52fc in vm_copy ()
#3 0x0000000180916b78 in szone_realloc ()
#4 0x000000018093cfb0 in _malloc_zone_realloc ()
#5 0x000000018093d7e8 in _realloc ()
#6 0x0000000180bb8a10 in __CFSafelyReallocate ()
#7 0x0000000181d00e30 in _NSMutableDataGrowBytes ()
#8 0x0000000181ce2630 in -[NSConcreteMutableData appendBytes:length:] ()
#9 0x00000001823c30d8 in -[_NSDataCompressor processBytes:size:flags:] ()
#10 0x00000001823c32c4 in -[NSData(NSDataCompression) _produceDataWithCompressionOperation:algorithm:handler:] ()
#11 0x00000001823c3598 in -[NSData(NSDataCompression) _decompressedDataUsingCompressionAlgorithm:error:] ()
It looks like something is wrong with safe reallocation, however if this have been a bug, then all macOS is stuck.
Any idea, please?
Post not yet marked as solved
Hello, I recently implemented a lock that uses OSAllocatedUnfairLock on iOS 16+ and os_unfair_lock on below iOS 16.
I know that using os_unfair_lock with Swift is tricky, and it is error-prone. For example, the famous open-source library Alamofire has even been using os_unfair_lock incorrectly in terms of Swift's lifecycle view. (They fixed it as in the link [1] )
So, I implemented a lock like below. To use os_unfair_lock safely, I used the Noncopyable protocol which was added in Swift 5.9 [2]. Also, I allocated memory on the heap to use os_unfair_lock.
public struct UnfairLock: ~Copyable {
public init() {
if #available(iOS 16.0, *) {
_osAllocatedUnfairLock = OSAllocatedUnfairLock()
} else {
self.unfairLock = UnsafeMutablePointer.allocate(capacity: 1)
}
}
deinit {
if #unavailable(iOS 16.0) {
unfairLock!.deallocate()
}
}
public func lock() {
if #available(iOS 16.0, *) {
osAllocatedUnfairLock.lock()
} else {
os_unfair_lock_lock(unfairLock!)
}
}
public func unlock() {
if #available(iOS 16.0, *) {
osAllocatedUnfairLock.unlock()
} else {
os_unfair_lock_unlock(unfairLock!)
}
}
public func with<T>(_ closure: () -> T) -> T {
lock()
defer { unlock() }
return closure()
}
private var _osAllocatedUnfairLock: Any?
private var unfairLock: UnsafeMutablePointer<os_unfair_lock_s>?
@available(iOS 16.0, *)
private var osAllocatedUnfairLock: OSAllocatedUnfairLock<Void> {
// swiftlint:disable force_cast
_osAllocatedUnfairLock as! OSAllocatedUnfairLock
// swiftlint:enable force_cast
}
}
However, I got several crashes on iOS 14-15 users like this (This app targets iOS 14+ and on iOS 16+, it uses OSAllocatedUnfairLock):
(Sorry for using a third-party crash reporting tool's log, but I think it is enough to understand the issue)
BUG IN CLIENT OF LIBPLATFORM: os_unfair_lock is corrupt
Crashed: com.foo.bar.queue
0 libsystem_platform.dylib 0x6144 _os_unfair_lock_corruption_abort + 88
1 libsystem_platform.dylib 0xa20 _os_unfair_lock_lock_slow + 320
2 FoooBarr 0x159416c closure #1 in static FooBar.baz() + 6321360
3 FoooBarr 0x2e65b8 thunk for @escaping @callee_guaranteed @Sendable () -> () + 4298794424 (<compiler-generated>:4298794424)
4 libdispatch.dylib 0x1c04 _dispatch_call_block_and_release + 32
5 libdispatch.dylib 0x3950 _dispatch_client_callout + 20
6 libdispatch.dylib 0x6e04 _dispatch_continuation_pop + 504
7 libdispatch.dylib 0x6460 _dispatch_async_redirect_invoke + 596
8 libdispatch.dylib 0x14f48 _dispatch_root_queue_drain + 388
9 libdispatch.dylib 0x15768 _dispatch_worker_thread2 + 164
10 libsystem_pthread.dylib 0x1174 _pthread_wqthread + 228
11 libsystem_pthread.dylib 0xf50 start_wqthread + 8
( libplatform's source code [3] suggests that __ulock_wait returns error, but I don't know the details)
Per @eskimo 's suggestion in [4], I will change my code to use NSLock until OSAllocatedUnfairLock is available on all users' devices (i.e. iOS 16+), but I still want to know why this crash happens.
I believe that making a struct Noncopyable is enough to use os_unfair_lock safely, but it seems that it is not enough. Did I miss something? Or is there any other way to use os_unfair_lock safely?
[1] https://github.com/Alamofire/Alamofire/commit/1b89a57c2f272408b84d20132a2ed6628e95d3e2
[2] https://github.com/apple/swift-evolution/blob/1b0b339bc3072a83b5a6a529ae405a0f076c7d5d/proposals/0390-noncopyable-structs-and-enums.md
[3] https://github.com/apple-open-source/macos/blob/ea4cd5a06831aca49e33df829d2976d6de5316ec/libplatform/src/os/lock.c#L555
[4] https://forums.developer.apple.com/forums/thread/712379
Post not yet marked as solved
I was expecting all of the code to run in main thread, but both task and async function is working in backfround thread. Any explanations?
anmarb.
