internal seem use

Author: dileping

ExecutionContext/ExecutionContext.swift

@@ -129,24 +129,16 @@ extension ExecutionContextType {
     func syncThroughAsync<ReturnType>(task:() throws -> ReturnType) throws -> ReturnType {
         var result:Result<ReturnType, AnyError>?
 
-        let cond = NSCondition()
-        var done = false
+        let sema = Semaphore()
 
         async {
             defer {
-                cond.lock()
-                done = true
-                cond.signal()
-                cond.unlock()
+                sema.signal()
             }
             result = materialize(task)
         }
 
-        cond.lock()
-        while !done {
-            cond.wait()
-        }
-        cond.unlock()
+        sema.wait()
 
         return try result!.dematerializeAnyError()
     }

ExecutionContext/PThreadExecutionContext.swift

@@ -73,15 +73,16 @@
 
         override init() {
             var runLoop:RunLoop?
-            let cond = NSCondition()
-            cond.lock()
+            let sema = Semaphore()
+            
             PThread(task: {
                 runLoop = RunLoop.currentRunLoop(true)
-                cond.signal()
+                sema.signal()
                 RunLoop.run()
             }).start()
-            cond.wait()
-            cond.unlock()
+            
+            sema.wait()
+
             self.rl = runLoop!
         }
 

ExecutionContext/Semaphore.swift

@@ -40,10 +40,10 @@ public class Semaphore {
         self.value = value
     }
 
-    /// Creates a new semaphore with initial value 1
+    /// Creates a new semaphore with initial value 0
     /// This kind of semaphores is useful to protect a critical section
     public convenience init() {
-        self.init(value: 1)
+        self.init(value: 0)
     }
 
     /// returns true on success (false if timeout expired)