import scala.actors.Actor

List("one", "two", "three", "four").foreach { name =>
new Actor { override def act() = { println("Thread " + name + " says Hello World!") } }.start
}

import java.util.concurrent.locks.ReentrantReadWriteLock
import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock
import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock
import scala.util.Random

class Reader(name: String, lock: ReadLock) extends Thread {
override def run() = {
println(name)
while (true) {
if (!lock.tryLock)
{
println("Thread " + name + " tried to read the value, but could not.")
lock.lock
}
println("Thread " + name + " says that the value is " + rwLockOnSharedResource.value)
lock.unlock
Thread.sleep(3) // Generates output more similar to the problem description
}
}
}

class Writer(name: String, lock: WriteLock) extends Thread {
override def run() = {
while (true) {
if (!lock.tryLock) {
println("Thread " + name + " tried to write the value, but could not.")
lock.lock
}
println("Thread " + name + " is taking the lock.")
rwLockOnSharedResource.value = rwLockOnSharedResource.nextValue
println("Thread " + name + " is changing the value to " + rwLockOnSharedResource.value)
lock.unlock
println("Thread " + name + " is releasing the lock.")
Thread.sleep(3) // Generates output more similar to the problem description
}
}
}

object rwLockOnSharedResource {
private val maxValue = 10
private val randomVal = new Random
var value = nextValue

def nextValue = randomVal.nextInt(maxValue)

def main(args: Array[String]) = {
val rwLock = new ReentrantReadWriteLock(true)
val threadNames = List("one", "two", "three", "four", "five")
val readerCnt = threadNames.length * 2 / 3
val readerNames = threadNames.take(readerCnt)
val writerNames = threadNames.drop(readerCnt)

readerNames.foreach(new Reader(_, rwLock.readLock).start)
writerNames.foreach(new Writer(_, rwLock.writeLock).start)
}
}

import scala.actors.Actor

object Worker extends Actor {
def perm(s: String): List[String] =
s.length match {
case 0 => Nil
case 1 => s :: Nil
case sLen => (0 to sLen-1).map(i => perm(s.take(i) + s.drop(i+1)).map(s(i) + _)).toList.flatten
}

def act() = react {
case "EXIT" =>
println("We're quitting! Alright!")
case (s: String) =>
val r = perm(s)
println("Done working on " + s + "!")
print("[ ")
r.foreach(s => print("\"" + s + "\", "))
println("]")
act()
}
}

object userInteractBackgroundCalc {
def main(args: Array[String]) {
print("Hello user! ")
Worker.start
var str = ""

do {
println("Please input a string to permute:")
str = readLine()
Worker ! str
} while (str != "EXIT")
}
}