availability check, native array loop for signal

Author: TheIronBorn

DiningPhilosophers/Sources/main.swift

@@ -7,17 +7,16 @@
 //
 
 
-import Foundation
 import Dispatch
 
 let numberOfPhilosophers = 4
 
 struct ForkPair {
-    static let forksSemaphore:[DispatchSemaphore] = Array(repeating: DispatchSemaphore(value: 1), count: numberOfPhilosophers)
-    
+    static let forksSemaphore: [DispatchSemaphore] = Array(repeating: DispatchSemaphore(value: 1), count: numberOfPhilosophers)
+
     let leftFork: DispatchSemaphore
     let rightFork: DispatchSemaphore
-    
+
     init(leftIndex: Int, rightIndex: Int) {
         //Order forks by index to prevent deadlock
         if leftIndex > rightIndex {
@@ -35,7 +34,7 @@ struct ForkPair {
         leftFork.wait()
         rightFork.wait()
     }
-    
+
     func putDown() {
         //The order does not matter here
         leftFork.signal()
@@ -47,61 +46,60 @@ struct ForkPair {
 struct Philosophers {
     let forkPair: ForkPair
     let philosopherIndex: Int
-    
+
     var leftIndex = -1
     var rightIndex = -1
-    
+
     init(philosopherIndex: Int) {
         leftIndex = philosopherIndex
         rightIndex = philosopherIndex - 1
-        
+
         if rightIndex < 0 {
             rightIndex += numberOfPhilosophers
         }
 
         self.forkPair = ForkPair(leftIndex: leftIndex, rightIndex: rightIndex)
         self.philosopherIndex = philosopherIndex
-        
+
         print("Philosopher: \(philosopherIndex)  left: \(leftIndex)  right: \(rightIndex)")
     }
-    
+
     func run() {
         while true {
-            print("Acquiring lock for Philosofer: \(philosopherIndex) Left:\(leftIndex) Right:\(rightIndex)")
+            print("Acquiring lock for Philosopher: \(philosopherIndex) Left:\(leftIndex) Right:\(rightIndex)")
             forkPair.pickUp()
             print("Start Eating Philosopher: \(philosopherIndex)")
             //sleep(1000)
-            print("Releasing lock for Philosofer: \(philosopherIndex) Left:\(leftIndex) Right:\(rightIndex)")
+            print("Releasing lock for Philosopher: \(philosopherIndex) Left:\(leftIndex) Right:\(rightIndex)")
             forkPair.putDown()
         }
     }
 }
 
 
-// Layout of the table (P = philosopher, f = fork) for 4 Philosopher
+// Layout of the table (P = philosopher, f = fork) for 4 Philosophers
 //          P0
 //       f3    f0
 //     P3        P1
 //       f2    f1
 //          P2
-
 let globalSem = DispatchSemaphore(value: 0)
 
 for i in 0..<numberOfPhilosophers {
-    DispatchQueue.global(qos: .background).async {
-        let p = Philosophers(philosopherIndex: i)
-        
-        p.run()
+    if #available(macOS 10.10, *) {
+        DispatchQueue.global(qos: .background).async {
+            let p = Philosophers(philosopherIndex: i)
+
+            p.run()
+        }
     }
 }
 
-//start the thread signaling the semaphore
-for i in 0..<numberOfPhilosophers {
-    ForkPair.forksSemaphore[i].signal()
+//Start the thread signaling the semaphore
+for semaphore in ForkPair.forksSemaphore {
+    semaphore.signal()
 }
 
 
-//wait forever
+//Wait forever
 globalSem.wait()
-
-