Add NSLock.withLock(_:) method

Sources/Foundation/NSLock.swift

@@ -22,6 +22,19 @@ public protocol NSLocking {
     func unlock()
 }
 
+extension NSLocking {
+    @_alwaysEmitIntoClient
+    @_disfavoredOverload
+    public func withLock<R>(_ body: () throws -> R) rethrows -> R {
+        self.lock()
+        defer {
+            self.unlock()
+        }
+
+        return try body()
+    }
+}
+
 #if os(Windows)
 private typealias _MutexPointer = UnsafeMutablePointer<SRWLOCK>
 private typealias _RecursiveMutexPointer = UnsafeMutablePointer<CRITICAL_SECTION>

Tests/Foundation/Tests/TestNSLock.swift

@@ -14,6 +14,7 @@ class TestNSLock: XCTestCase {
             ("test_lockWait", test_lockWait),
             ("test_threadsAndLocks", test_threadsAndLocks),
             ("test_recursiveLock", test_recursiveLock),
+            ("test_withLock", test_withLock),
 
         ]
     }
@@ -187,4 +188,33 @@ class TestNSLock: XCTestCase {
 
         threadCompletedCondition.unlock()
     }
+
+    func test_withLock() {
+        let lock = NSLock()
+
+        var counter = 0
+        let counterIncrementPerThread = 10_000
+
+        let threadCount = 10
+
+        let threadCompletedExpectation = expectation(description: "Expected threads to complete.")
+        threadCompletedExpectation.expectedFulfillmentCount = threadCount
+
+        for _ in 0..<threadCount {
+            let thread = Thread {
+                for _ in 0..<counterIncrementPerThread {
+                    lock.withLock {
+                        counter += 1
+                    }
+                }
+
+                threadCompletedExpectation.fulfill()
+            }
+            thread.start()
+        }
+
+        wait(for: [threadCompletedExpectation], timeout: 10)
+
+        XCTAssertEqual(counter, counterIncrementPerThread * threadCount)
+    }
 }