Added some documentations to AsyncLock file

RxSwift/Concurrency/AsyncLock.swift

@@ -29,16 +29,58 @@ final class AsyncLock<I: InvocableType>
     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 @@ final class AsyncLock<I: InvocableType>
         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 @@ final class AsyncLock<I: InvocableType>
         }
     }
 
+    /**
+     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 @@ final class AsyncLock<I: InvocableType>
             }
         }
     }
-
+
+    // 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