fix bug

杨锴

2025-03-11 90dc3329d1973fda691e357cf4523d5c7c67fa1d

 Pods/RxSwift/RxSwift/Concurrency/AsyncLock.swift

@@ -29,16 +29,58 @@
    private var isExecuting: Bool = false
    private var hasFaulted: Bool = false

    // lock {
    /**
     Locks the current instance, preventing other threads from modifying it until `unlock()` is called.

     This method is used to create a critical section where only one thread is allowed to access the protected resources at a time.

     Example usage:
     ```swift
     let lock = AsyncLock<SomeAction>()
     lock.lock()
     // Critical section
     lock.unlock()
     ```
     */
    func lock() {
        self._lock.lock()
    }

    /**
     Unlocks the current instance, allowing other threads to access the protected resources.

     This method is called after a `lock()` to release the critical section, ensuring that other waiting threads can proceed.

     Example usage:
     ```swift
     let lock = AsyncLock<SomeAction>()
     lock.lock()
     // Critical section
     lock.unlock()
     ```
     */
    func unlock() {
        self._lock.unlock()
    }
    // }
    
    // MARK: - Queue Methods

    /**
     Enqueues an action into the internal queue for deferred execution.

     If no actions are currently being executed, the method returns the action for immediate execution. Otherwise, the action is enqueued for deferred execution when the lock is available.

     - Parameter action: The action to enqueue.
     - Returns: The action if it can be executed immediately, or `nil` if it has been enqueued.

     Example usage:
     ```swift
     let lock = AsyncLock<SomeAction>()
     if let action = lock.enqueue(someAction) {
     action.invoke()  // Execute the action immediately if it's not deferred.
     }
     ```
     */
    private func enqueue(_ action: I) -> I? {
        self.lock(); defer { self.unlock() }
        if self.hasFaulted {
@@ -55,6 +97,19 @@
        return action
    }

    /**
     Dequeues the next action for execution, if available.

     If the queue is empty, this method resets the `isExecuting` flag to indicate that no actions are currently being executed.

     - Returns: The next action from the queue, or `nil` if the queue is empty.

     Example usage:
     ```swift
     let nextAction = lock.dequeue()
     nextAction?.invoke()  // Execute the next action if one is available.
     ```
     */
    private func dequeue() -> I? {
        self.lock(); defer { self.unlock() }
        if !self.queue.isEmpty {
@@ -66,6 +121,19 @@
        }
    }

    /**
     Invokes the provided action, ensuring that actions are executed sequentially.

     The first action is executed immediately if no other actions are currently running. If other actions are already in the queue, the new action is enqueued and executed sequentially after the current actions are completed.

     - Parameter action: The action to be invoked.

     Example usage:
     ```swift
     let lock = AsyncLock<SomeAction>()
     lock.invoke(someAction)  // Invoke or enqueue the action.
     ```
     */
    func invoke(_ action: I) {
        let firstEnqueuedAction = self.enqueue(action)
        
@@ -88,11 +156,34 @@
            }
        }
    }
    

    // MARK: - Dispose Methods

    /**
     Disposes of the `AsyncLock` by clearing the internal queue and preventing further actions from being executed.

     This method ensures that all pending actions are discarded, and the lock enters a faulted state where no new actions can be enqueued or executed.

     Example usage:
     ```swift
     let lock = AsyncLock<SomeAction>()
     lock.dispose()  // Clear the queue and prevent further actions.
     ```
     */
    func dispose() {
        self.synchronizedDispose()
    }

    /**
     Synchronously disposes of the internal queue and marks the lock as faulted.
     
     This method is typically used internally to handle disposal of the lock in a thread-safe manner.
     
     Example usage:
     ```swift
     lock.synchronized_dispose()
     ```
     */
    func synchronized_dispose() {
        self.queue = Queue(capacity: 0)
        self.hasFaulted = true