Question

我把 s/yn世界迅速拉开,并逐步采用yn/awa。我试图援引一种从非同化功能中恢复价值的作用。我的理解是,如上所述,here 。

例子实际上并不合适,因为这项任务没有回报价值。

在进行大量搜查之后,我没有能够找到对我认为是一个非常常见的问题的任何描述:nch忙地援引一项同步的任务(而且,我的理解是,这可以冻结主线)。

从理论上讲,我要在我的同步职能中写道:

let x = Task {
  return await someAsyncFunction()
}.result

然而,在我尝试这样做时,由于试图查阅<条码>result<>/代码>,我发现这一汇编错误:

。

我发现的一个替代办法是:

Task.init {
  self.myResult = await someAsyncFunction()
}

www.un.org/Depts/DGACM/index_french.htm

然而,这并没有达到我所希望的方式,因为没有保证在<条码>之前完成这项任务。因此,我如何能够 wait忙地等待完成这项任务?

Answer 1

你们不应 wait忙地等待着一件好事。

One may come up with a solution similar to this:

func updateDatabase(_ asyncUpdateDatabase: @Sendable @escaping () async -> Void) {
    let semaphore = DispatchSemaphore(value: 0)

    Task {
        await asyncUpdateDatabase()
        semaphore.signal()
    }

    semaphore.wait()
}

虽然它在某些简单的条件下开展工作,但据

各种途径总是能够取得进展。

这意味着深处永远不会受阻。如果法院的职能达到中止点(如等待表达),则该职能可以中止,但表面不会阻碍,它可以做其他工作。根据这一合同,新的合作校对池只能够铺开许多路面,因为有CPU核心,避免过度的渗透环境变化。这一合同也是造成僵局的关键原因。

上述情况违反了这一合同。 <代码>semaphore.wait()功能穿透。这可能造成问题。例如

func testGroup() {
    Task {
        await withTaskGroup(of: Void.self) { group in
            for _ in 0 ..< 100 {
                group.addTask {
                    syncFunc()
                }
            }
        }
        NSLog("Complete")
    }
}

func syncFunc() {
    let semaphore = DispatchSemaphore(value: 0)
    Task {
        try? await Task.sleep(nanoseconds: 1_000_000_000)
        semaphore.signal()
    }
    semaphore.wait()
}

Here we add 100 concurrent child tasks in the testGroup function, unfortunately the task group will never complete. In my Mac, the system spawns 4 cooperative threads, adding only 4 child tasks is enough to block all 4 threads indefinitely. Because after all 4 threads are blocked by the wait function, there is no more thread available to execute the inner task that signals the semaphore.

不安全使用的另一个例子是行为者的僵局:

func testActor() {
    Task {
        let d = Database()
        await d.updateSettings()
        NSLog("Complete")
    }
}

func updateDatabase(_ asyncUpdateDatabase: @Sendable @escaping () async -> Void) {
    let semaphore = DispatchSemaphore(value: 0)

    Task {
        await asyncUpdateDatabase()
        semaphore.signal()
    }

    semaphore.wait()
}

actor Database {
    func updateSettings() {
        updateDatabase {
            await self.updateUser()
        }
    }

    func updateUser() {

    }
}

此处称为<代码>更新功能将陷入僵局。由于它等待了<代码>更新日期User的功能,而<代码>更新用户功能与同一行为体隔绝,因此,它等待<代码>更新<<>> >。

以上两个例子使用<代码>DispadSemaphore。同样,使用NS Conditions也是不安全的。基本上等待同步,意味着阻挡目前的read。避免这种模式,除非你只想临时解决办法并充分了解风险。

Answer 2

除使用ema光外,你还可以在以下网站完成你的日常工作:,如。您可以发出信号,在基本任务完成后,使用 wait UntilFinished(:

let op = TaskOperation {
   try await Task.sleep(nanoseconds: 1_000_000_000)
}
op.waitUntilFinished()

请注意,使用<代码>semaphore.wait()或op.wait UntilFinished( >,阻挡了目前对面的read,可能会造成现代一致的不确定的操作时间行为,因为现代一致假设所有线索都在不断取得进展。如果你计划只在你不使用现代一致性的情况下使用这种方法,那么,如果你能够提供在不成熟的情况下无法使用的特性标识方法:

@available(*, noasync, message: "this method blocks thread use the async version instead")
func yourBlockingFunc() {
    // do work that can block thread
}

借助这一属性,你只能从非同化的角度援引这一方法。但是,需要谨慎一些,因为如果这种方法没有具体规定<条码>不适用>。

Answer 3

我写了简单的功能,可以像科特林那样,作为同步的法典操作,你可以看到代码。仅用于测试目的的。 ∗∗∗∗∗

例:

let result = runBlocking { try? await Task.sleep(nanoseconds: 1_000_000_000) return "Some result" } print(result) // prints "Some result"

Answer 4

页: 1 内容和用途

Task.synchronous { try await myAsyncFunc() }

利用这一简单延伸:

extension Task where Failure == Error {
    /// Performs an async task in a sync context.
    ///
    /// - Note: This function blocks the thread until the given operation is finished. The caller is responsible for managing multithreading.
    static func synchronous(priority: TaskPriority? = nil, operation: @escaping @Sendable () async throws -> Success) {
        let semaphore = DispatchSemaphore(value: 0)

        Task(priority: priority) {
            defer { semaphore.signal() }
            return try await operation()
        }

        semaphore.wait()
    }
}

这里是使用的一个例子:

func synchronousContext() { // ? No `async` keyword here

    let duration: UInt64 = 2_000_000_000 /* 2 seconds */
    var seconds: UInt64 { duration/1_000_000_000 }

    print("Start: Should wait for (seconds) seconds...")

    Task.synchronous { try await Task.sleep(nanoseconds: duration) } // ? No `await` keyword for calling the `Task.synchronous `

    print("...Ended after (seconds) seconds")
}

Answer 5

The following code can return a value from an async function using a function that is not async:

func performAsyncTask() -> Any? {
    class Enclosure {
        var value: Any?
    }
    
    let semaphore = DispatchSemaphore(value: 0)
    let enclosure = Enclosure()
    
    Task {
        enclosure.value = await yourAsyncFunction()
        semaphore.signal()
    }
    
    semaphore.wait()
    return enclosure.value
}

正如在其他答复中指出的那样,这将阻碍目前的工作,直到完成“合成”的任务,因此,你应当能够理解风险并谨慎行事。

友情链接