swap concurrent Task2/Task3

Author: eupp

src/main/kotlin/cub/concurrent/answers/Task2.kt

@@ -1,78 +1,23 @@
 package cub.concurrent.answers
 
-import kotlin.concurrent.*
-import java.util.concurrent.locks.*
-
-/*
- * Implement simple thread-safe blocking stack.
- * Use usual mutable list as an underlying storage.
- *
- * Methods can block the calling thread if they are executed concurrently with other methods.
- * Additionally, pop operation can also block the thread if the stack is empty ---
- * in this case it should wait until some value will be pushed to the stack.
- */
-class SynchronizedBlockingStack<T> {
-    private val list = mutableListOf<T>()
-    private val lock = ReentrantLock()
-    private val condition = lock.newCondition()
-
-    fun push(value: T) = lock.withLock {
-        list.add(value)
-        condition.signal()
-    }
-
-    fun pop(): T = lock.withLock {
-        while (list.isEmpty()) {
-            condition.await()
+import java.util.concurrent.ConcurrentLinkedQueue
+import kotlin.concurrent.thread
+
+fun<T> Collection<T>.parallelForEach(nThreads: Int, block: (T) -> Unit) {
+    require(nThreads > 0) { "The number of threads must be > 0" }
+    val queue = ConcurrentLinkedQueue(this)
+    val threadPool = (0 until nThreads).map { _ ->
+        thread {
+            while (true) {
+                block(queue.poll() ?: return@thread)
+            }
         }
-        list.removeLast()
-    }
-
-    fun top(): T? = lock.withLock {
-        list.lastOrNull()
-    }
-
-    fun size(): Int = lock.withLock {
-        list.size
-    }
-}
-
-fun test1() {
-    val stack = SynchronizedBlockingStack<Int>()
-    thread {
-        stack.push(1)
-    }
-    thread {
-        stack.push(2)
-        stack.push(3)
-    }
-    thread {
-        val a = stack.pop()
-        val b = stack.pop()
-        val c = stack.pop()
-        println("a=$a, b=$b, c=$c")
-        // can print either:
-        // a=3, b=2, a=1
-        // a=1, b=3, c=2
-        // a=3, b=1, a=2
     }
-}
-
-fun test2() {
-    val stack = SynchronizedBlockingStack<Int>()
-    thread {
-        println("push(1)")
-        stack.push(1)
-    }
-    thread {
-        val r = stack.pop()
-        println("pop(): $r")
-    }
-    // can only print lines in the following sequence:
-    // push(1), pop():1
+    threadPool.forEach { it.join() }
 }
 
 fun main() {
-    test1()
-    test2()
+    (1 .. 10).toList().parallelForEach(4) { i ->
+        println("${i * i}")
+    }
 }

src/main/kotlin/cub/concurrent/answers/Task3.kt

@@ -1,23 +1,78 @@
 package cub.concurrent.answers
 
-import java.util.concurrent.ConcurrentLinkedQueue
-import kotlin.concurrent.thread
-
-fun<T> Collection<T>.parallelForEach(nThreads: Int, block: (T) -> Unit) {
-    require(nThreads > 0) { "The number of threads must be > 0" }
-    val queue = ConcurrentLinkedQueue(this)
-    val threadPool = (0 until nThreads).map { _ ->
-        thread {
-            while (true) {
-                block(queue.poll() ?: return@thread)
-            }
+import kotlin.concurrent.*
+import java.util.concurrent.locks.*
+
+/*
+ * Implement simple thread-safe blocking stack.
+ * Use usual mutable list as an underlying storage.
+ *
+ * Methods can block the calling thread if they are executed concurrently with other methods.
+ * Additionally, pop operation can also block the thread if the stack is empty ---
+ * in this case it should wait until some value will be pushed to the stack.
+ */
+class SynchronizedBlockingStack<T> {
+    private val list = mutableListOf<T>()
+    private val lock = ReentrantLock()
+    private val condition = lock.newCondition()
+
+    fun push(value: T) = lock.withLock {
+        list.add(value)
+        condition.signal()
+    }
+
+    fun pop(): T = lock.withLock {
+        while (list.isEmpty()) {
+            condition.await()
         }
+        list.removeLast()
+    }
+
+    fun top(): T? = lock.withLock {
+        list.lastOrNull()
+    }
+
+    fun size(): Int = lock.withLock {
+        list.size
     }
-    threadPool.forEach { it.join() }
 }
 
-fun main() {
-    (1 .. 10).toList().parallelForEach(4) { i ->
-        println("${i * i}")
+fun test1() {
+    val stack = SynchronizedBlockingStack<Int>()
+    thread {
+        stack.push(1)
     }
+    thread {
+        stack.push(2)
+        stack.push(3)
+    }
+    thread {
+        val a = stack.pop()
+        val b = stack.pop()
+        val c = stack.pop()
+        println("a=$a, b=$b, c=$c")
+        // can print either:
+        // a=3, b=2, a=1
+        // a=1, b=3, c=2
+        // a=3, b=1, a=2
+    }
+}
+
+fun test2() {
+    val stack = SynchronizedBlockingStack<Int>()
+    thread {
+        println("push(1)")
+        stack.push(1)
+    }
+    thread {
+        val r = stack.pop()
+        println("pop(): $r")
+    }
+    // can only print lines in the following sequence:
+    // push(1), pop():1
+}
+
+fun main() {
+    test1()
+    test2()
 }

src/main/kotlin/cub/concurrent/tasks/Task2.kt

@@ -1,73 +1,21 @@
 package cub.concurrent.tasks
 
-import cub.concurrent.answers.SynchronizedBlockingStack
-import kotlin.concurrent.thread
-
 /*
- * Implement simple thread-safe blocking stack.
- * Use usual mutable list as an underlying storage.
+ * Implement parallel version of forEach function, which applies given lambda to all elements of the collection.
+ * Your implementation should distribute the work between threads dynamically.
+ * That is you should not split the list into chunks of equal size and pass each chunk to a separate thread.
+ * Instead, create a thread pool and in each thread handle elements one-by-one.
+ *
+ * Parameter `nThreads` specifies the number of threads that should be used to perform the job.
  *
- * Methods can block the calling thread if they are executed concurrently with other methods.
- * Additionally, pop operation can also block the thread if the stack is empty ---
- * in this case it should wait until some value will be pushed to the stack.
  */
-class SynchronizedBlockingStack<T> {
-    private val list = mutableListOf<T>()
-
-    fun push(value: T) {
-        TODO()
-    }
-
-    fun pop(): T {
-        TODO()
-    }
-
-    fun top(): T? {
-        TODO()
-    }
-
-    fun size(): Int {
-        TODO()
-    }
-}
-
-fun test1() {
-    val stack = SynchronizedBlockingStack<Int>()
-    thread {
-        stack.push(1)
-    }
-    thread {
-        stack.push(2)
-        stack.push(3)
-    }
-    thread {
-        val a = stack.pop()
-        val b = stack.pop()
-        val c = stack.pop()
-        println("a=$a, b=$b, c=$c")
-        // can print either:
-        // a=3, b=2, a=1
-        // a=1, b=3, c=2
-        // a=3, b=1, a=2
-    }
-}
-
-fun test2() {
-    val stack = SynchronizedBlockingStack<Int>()
-    thread {
-        println("push(1)")
-        stack.push(1)
-    }
-    thread {
-        val r = stack.pop()
-        println("pop(): $r")
-    }
-    // can only print lines in the following sequence:
-    // push(1)
-    // pop():1
+fun<T> Collection<T>.parallelForEach(nThreads: Int, block: (T) -> Unit) {
+    require(nThreads > 0) { "The number of threads must be > 0" }
+    TODO()
 }
 
 fun main() {
-    test1()
-    test2()
+    (1 .. 10).toList().parallelForEach(4) { i ->
+        println("${i * i}")
+    }
 }

src/main/kotlin/cub/concurrent/tasks/Task3.kt

@@ -1,21 +1,73 @@
 package cub.concurrent.tasks
 
+import cub.concurrent.answers.SynchronizedBlockingStack
+import kotlin.concurrent.thread
+
 /*
- * Implement parallel version of forEach function, which applies given lambda to all elements of the collection.
- * Your implementation should distribute the work between threads dynamically.
- * That is you should not split the list into chunks of equal size and pass each chunk to a separate thread.
- * Instead, create a thread pool and in each thread handle elements one-by-one.
- *
- * Parameter `nThreads` specifies the number of threads that should be used to perform the job.
+ * Implement simple thread-safe blocking stack.
+ * Use usual mutable list as an underlying storage.
  *
+ * Methods can block the calling thread if they are executed concurrently with other methods.
+ * Additionally, pop operation can also block the thread if the stack is empty ---
+ * in this case it should wait until some value will be pushed to the stack.
  */
-fun<T> Collection<T>.parallelForEach(nThreads: Int, block: (T) -> Unit) {
-    require(nThreads > 0) { "The number of threads must be > 0" }
-    TODO()
+class SynchronizedBlockingStack<T> {
+    private val list = mutableListOf<T>()
+
+    fun push(value: T) {
+        TODO()
+    }
+
+    fun pop(): T {
+        TODO()
+    }
+
+    fun top(): T? {
+        TODO()
+    }
+
+    fun size(): Int {
+        TODO()
+    }
 }
 
-fun main() {
-    (1 .. 10).toList().parallelForEach(4) { i ->
-        println("${i * i}")
+fun test1() {
+    val stack = SynchronizedBlockingStack<Int>()
+    thread {
+        stack.push(1)
+    }
+    thread {
+        stack.push(2)
+        stack.push(3)
+    }
+    thread {
+        val a = stack.pop()
+        val b = stack.pop()
+        val c = stack.pop()
+        println("a=$a, b=$b, c=$c")
+        // can print either:
+        // a=3, b=2, a=1
+        // a=1, b=3, c=2
+        // a=3, b=1, a=2
+    }
+}
+
+fun test2() {
+    val stack = SynchronizedBlockingStack<Int>()
+    thread {
+        println("push(1)")
+        stack.push(1)
+    }
+    thread {
+        val r = stack.pop()
+        println("pop(): $r")
     }
+    // can only print lines in the following sequence:
+    // push(1)
+    // pop():1
+}
+
+fun main() {
+    test1()
+    test2()
 }