June 2018 Update

Task/Checkpoint-synchronization/Go/checkpoint-synchronization-1.go

@@ -0,0 +1,34 @@
+package main
+
+import (
+    "log"
+    "math/rand"
+    "sync"
+    "time"
+)
+
+func worker(part string) {
+    log.Println(part, "worker begins part")
+    time.Sleep(time.Duration(rand.Int63n(1e6)))
+    log.Println(part, "worker completes part")
+    wg.Done()
+}
+
+var (
+    partList    = []string{"A", "B", "C", "D"}
+    nAssemblies = 3
+    wg          sync.WaitGroup
+)
+
+func main() {
+    rand.Seed(time.Now().UnixNano())
+    for c := 1; c <= nAssemblies; c++ {
+        log.Println("begin assembly cycle", c)
+        wg.Add(len(partList))
+        for _, part := range partList {
+            go worker(part)
+        }
+        wg.Wait()
+        log.Println("assemble.  cycle", c, "complete")
+    }
+}

Task/Checkpoint-synchronization/Go/checkpoint-synchronization-2.go

@@ -0,0 +1,40 @@
+package main
+
+import (
+    "log"
+    "math/rand"
+    "strings"
+    "time"
+)
+
+func worker(part string, completed chan string) {
+    log.Println(part, "worker begins part")
+    time.Sleep(time.Duration(rand.Int63n(1e6)))
+    p := strings.ToLower(part)
+    log.Println(part, "worker completed", p)
+    completed <- p
+}
+
+var (
+    partList    = []string{"A", "B", "C", "D"}
+    nAssemblies = 3
+)
+
+func main() {
+    rand.Seed(time.Now().UnixNano())
+    completed := make([]chan string, len(partList))
+    for i := range completed {
+        completed[i] = make(chan string)
+    }
+    for c := 1; c <= nAssemblies; c++ {
+        log.Println("begin assembly cycle", c)
+        for i, part := range partList {
+            go worker(part, completed[i])
+        }
+        a := ""
+        for _, c := range completed {
+            a += <-c
+        }
+        log.Println(a, "assembled.  cycle", c, "complete")
+    }
+}

Task/Checkpoint-synchronization/Go/checkpoint-synchronization-3.go

@@ -0,0 +1,64 @@
+package main
+
+import (
+    "log"
+    "math/rand"
+    "strings"
+    "sync"
+    "time"
+)
+
+func worker(part string, completed chan string) {
+    log.Println(part, "worker running")
+    for {
+        select {
+        case <-start:
+            log.Println(part, "worker begins part")
+            time.Sleep(time.Duration(rand.Int63n(1e6)))
+            p := strings.ToLower(part)
+            log.Println(part, "worker completed", p)
+            completed <- p
+            <-reset
+            wg.Done()
+        case <-done:
+            log.Println(part, "worker stopped")
+            wg.Done()
+            return
+        }
+    }
+}
+
+var (
+    partList    = []string{"A", "B", "C", "D"}
+    nAssemblies = 3
+    start       = make(chan int)
+    done        = make(chan int)
+    reset       chan int
+    wg          sync.WaitGroup
+)
+
+func main() {
+    rand.Seed(time.Now().UnixNano())
+    completed := make([]chan string, len(partList))
+    for i, part := range partList {
+        completed[i] = make(chan string)
+        go worker(part, completed[i])
+    }
+    for c := 1; c <= nAssemblies; c++ {
+        log.Println("begin assembly cycle", c)
+        reset = make(chan int)
+        close(start)
+        a := ""
+        for _, c := range completed {
+            a += <-c
+        }
+        log.Println(a, "assembled.  cycle", c, "complete")
+        wg.Add(len(partList))
+        start = make(chan int)
+        close(reset)
+        wg.Wait()
+    }
+    wg.Add(len(partList))
+    close(done)
+    wg.Wait()
+}

Task/Checkpoint-synchronization/Kotlin/checkpoint-synchronization.kotlin

@@ -0,0 +1,60 @@
+// Version 1.2.41
+
+import java.util.Random
+
+val rgen = Random()
+var nWorkers = 0
+var nTasks = 0
+
+class Worker(private val threadID: Int) : Runnable {
+
+    @Synchronized
+    override fun run() {
+        try {
+            val workTime = rgen.nextInt(900) + 100L  // 100..999 msec.
+            println("Worker $threadID will work for $workTime msec.")
+            Thread.sleep(workTime)
+            nFinished++
+            println("Worker $threadID is ready")
+        }
+        catch (e: InterruptedException) {
+            println("Error: thread execution interrupted")
+            e.printStackTrace()
+        }
+    }
+
+    companion object {
+        private var nFinished = 0
+
+        @Synchronized
+        fun checkPoint() {
+            while (nFinished != nWorkers) {
+                try {
+                    Thread.sleep(10)
+                }
+                catch (e: InterruptedException) {
+                    println("Error: thread execution interrupted")
+                    e.printStackTrace()
+                }
+            }
+            nFinished = 0  // reset
+        }
+    }
+}
+
+fun runTasks() {
+    for (i in 1..nTasks) {
+        println("\nStarting task number $i.")
+        // Create a thread for each worker and run it.
+        for (j in 1..nWorkers) Thread(Worker(j)).start()
+        Worker.checkPoint()  // wait for all workers to finish the task
+    }
+}
+
+fun main(args: Array<String>) {
+    print("Enter number of workers to use: ")
+    nWorkers = readLine()!!.toInt()
+    print("Enter number of tasks to complete: ")
+    nTasks = readLine()!!.toInt()
+    runTasks()
+}