1. Actor & STM
じゅんいち☆かとう
@j5ik2o

2. 並行処理 難しい

3. 何が難しいか
スレッドセーフ
が難しい

4. 原子性 可視性 順序性

5. スレッドと通信する
ことってあるよねー

6. Q1.スレッドを止められるか...
public class StopThread implements Runnable {
private boolean terminate;
public void run() {
while (! terminate) {
// なにかの処理
}
}
public void setTerminate(boolean terminate) {
this. terminate = terminate;
}
}

7. HotSpot ServerVMなら...
if (!terminate) {
while(true){
// なにかの処理
}
}

8. スレッド単位の
セマンティクス

9. こう思ったら間違いのもと
スレッドA terminate ← true
terminate
スレッドB true ← terminate

10. こう思ったら間違いのもと
スレッドA terminate ← true
スレッドB false ← terminate
true ← terminate

11. メモリモデルはスレッド単位
スレッドA terminate ← true terminate(true)
スレッドB false ← terminate terminate(false)

12. メモリモデルはスレッド単位
スレッドA terminate ← true terminate(true)
大域のterminate
スレッドB false ← terminate terminate(false)

13. メモリモデルはスレッド単位
スレッドA terminate ← true terminate(true)
同期化しないと
見えない 大域のterminate
スレッドB false ← terminate
true ← terminate terminate(false)
terminate(true)

14. これは可視性の問題
http://www.flickr.com/photos/teegardin/5547069087/sizes/m/in/photostream/

15. volatileェ...
public class StopThread implements Runnable {
private volatile boolean terminate;
public void run() {
// (2) Volatile Load
while (! terminate) {
// スレッドで行う処理
}
}
public void setTerminate(boolean terminate) {
// (1) Volatile Store
this. terminate = terminate;
}
}

16. Q2.x,yの結果はどうなる？
x = 0; y = 0; a = 0; b = 0;
class AThread extend class BThread extend
Runnable { Runnable {
@Override @Override
public void run() { public void run() {
a = 1; b = 1;
x = b; y = a;
} }
} }

17. (1,1),(1,0),
(0,1),(0,0)

18. 何回目で発生したか (x , y)
004590 (1 , 1)
005606 (0 , 0)
045450 (0 , 1)
045451 (1 , 0)
105747 (0 , 0)
129356 (0 , 0)

20. これは順序性の問題
http://www.flickr.com/photos/wahlander/3808866872/sizes/m/in/photostream/

21. (可変な)変数の共有と
ロック争奪に基づく
共有データ・
ロックモデル

22. • 読み書きしようとしているデータが他
のスレッドから読み書きされないか。
どのようなロックがかけられている
か。
• メソッドを呼び出す際にどのような
ロックを取得するか。その呼び出しに
よってデットロックがないか。

23. Scala with Actor

24. 共有なしの
メッセージ交換モデル

25. こんな感じ...

26. メッセージを受信するActor
class MyActor extends Actor {
def act() = { // Runnable#run相当
loop { // while(true)の簡略表現
receive { // メッセージの待ち受け(ブロックする)
case "end" => exit
case msg: String => println(msg)
}
}
}
}
val myactor = new MyActor
myactor.start()
// 文字列を渡す
myactor ! “Hello”
// 終了メッセージを渡す
myactor ! “end”

27. 返事を返すActor
val myactor = actor {
loop {
receive {
case "end" => exit
case "Hello" => reply("World")
}
}
}
// 戻り値を取得(返事が戻るまでブロック)
val result = myactor !? “Hello”

28. Futureを返すActor
val myactor = actor {
loop {
receive {
case "end" => exit
case numbers: List[Int] =>
重いソート処理
reply(result)
}
}
}
// futureパターン
val future = myactor !! largeNumbers
while(!future.isSet){ Thread.sleep(1000) }
val result = future()

29. もっと簡潔に
val myactor = actor {
loop {
receive {
case "end" => exit
case msg: String => println(msg)
}
}
}
// 文字列を渡す(ブロックしない)
myactor ! “Hello”
// 終了メッセージを渡す (ブロックしない)
myactor ! “end”

30. reactはスレッドを節約する
val myactor = actor {
loop {
react {
case "end" => exit
case numbers: List[Int] =>
重いソート処理
reply(result)
}
// 制御を返さないので,ここは実行できない
}
}

31. リソースを共有しない利点
class MyActor extends Actor {
def act() = { // Runnable#run相当
loop { // while(true)の簡略表現
receive { // メッセージの待ち受け(ブロックする)
case "end" => exit
case msg: String => println(msg)
}
}
}
} シングルスレッド脳
val myactor = new MyActor
myactor.start() で考えればよい
// 文字列を渡す
myactor ! “Hello”
// 終了メッセージを渡す
myactor ! “end”

32. mutalbleなメッセージはやめよう
class Money(var amount:BigDecimal, val actorA = new MyActor
var currency: Currency) {
def plus(add: Money):Unit = { val actorB = new MyActor
var a = amount val money = new Money(10,
a = a + add.amount
amount = a Currency.getInstance("JPY"
} ))
// いろいろ省略
actorA ! ("set", money)
} actorB ! ("set", money)
class MyActor extends Actor { actorA ! ("add", money)
var money: Money = _ actorB ! ("add", money)
def act() = {
loop {
react {
case "end" => exit
case ("set", m) => money = m
case ("add", m) =>
money.plus(m)
}
}
}
}

33. mutalbleなメッセージはやめよう
class Money(var amount:BigDecimal, val actorA = new MyActor
var currency: Currency) {
def plus(add: Money):Unit = { val actorB = new MyActor
var a = amount val money = new Money(10,
a = a + add.amount
amount = a Currency.getInstance("JPY"
} ))
// いろいろ省略
amount 参照の可視性
actorA ! ("set", money)
} actorB ! ("set", money)
plusメソッドの原子性
class MyActor extends Actor { actorA ! ("add", money)
var money: Money = _ actorB ! ("add", money)
def act() = {
loop {
react {
case "end" => exit
case ("set", m) => money = m
case ("add", m) =>
money.plus(m)
}
}
}
}

34. STM
(Software Transcational
Memoery)

35. スレッドセーフ？
class Sequence {
private var value = 0
def getValue = value
// ↓ スレッドセーフか？
def getAndIncrement() = {
value += 1 // Java だと value++
value
}
}

36. スレッドセーフ？
二つのスレッドから
sequence.getAndIncrement()
を1000回呼び出したら、最後
に2000になるか

37. 0182 1998
0848 1998
3438 1998
3714 1998
3950 1998

38. レースコンディション

39. これは原子性の問題
http://www.flickr.com/photos/swellzombie/4303343824/sizes/m/in/photostream/

40. ロックで同期化
class Sequence {
private var value = 0
def getValue = value
// ↓ ロックが必要
def getAndIncrement() = synchronized {
value += 1
value
}
}

41. STM(Ref)
class Sequence {
private var value = Ref(0)
def getValue = value.get
def getAndIncrement() = atomic {
value alter (_ + 1)
}
}
class Ref[T] ...
def alter(f: T T): T = {
val value = f(get)
set(value)
value
}