dwhitney

private val map = new java.util.HashMap[String, Account]()
map.put("from", Account("from", 500))
map.put("to", Account("to", 500))

val accountsRef = Ref(map)

  def transfer(fromNo: String, toNo: String, amount: Int): Unit = {
    atomic{ implicit t => 
      var accounts = accountsRef()
      val (from, to) = (accounts.get(fromNo), accounts.get(toNo))

dwhitney

import scala.concurrent.stm._ 

case class Account(accountNo: String, balance: Int){
  def credit(amount: Int) = this.copy(balance = (balance + amount))
  def debit(amount: Int) = this.copy(balance = (balance - amount))
}

object Bank{
        
  val accountsRef = Ref(Map("from" -> Account("from", 500), "to" -> Account("to", 500) ))

dwhitney

import scala.concurrent.stm._ 

class Account(val accountNo: String, beginningBalance: Int){
  private var _balance = beginningBalance
  def balance = this.synchronized{ _balance }
  def credit(amount: Int) = this.synchronized{ _balance = _balance + amount }
  def debit(amount: Int) = this.synchronized { _balance = _balance - amount }
}

object Bank{

dwhitney

private val map = new java.util.HashMap[String, Account]()
map.put("from", Account("from", 500))
map.put("to", Account("to", 500))

val accountsRef = Ref(map)
val hashMap = atomic{ implicit t => accountsRef() }
crazyThreads(hashMap)

dwhitney

private val map = new java.util.HashMap[String, Account]()
map.put("from", Account("from", 500))
map.put("to", Account("to", 500))

val accountsRef = Ref(map)

  def transfer(fromNo: String, toNo: String, amount: Int): Unit = {
    atomic{ implicit t => 
      var accounts = accountsRef()
      val (from, to) = (accounts.get(fromNo), accounts.get(toNo))

dwhitney

val shouldApplyTransferFees: Boolean = atomic{ implicit t =>
  var accounts = accountsRef()
  val (from, to) = (accounts(fromNo), accounts(toNo))
  if(from.balance > amount){
    accounts = accounts + (to.accountNo -> to.credit(amount))
    accounts = accounts + (from.accountNo -> from.debit(amount))
    accountsRef() = accounts
    true
  }else false
}

dwhitney

atomic{ implicit t =>
  var accounts = accountsRef()
  val (from, to) = (accounts(fromNo), accounts(toNo))
  if(from.balance > amount){
    accounts = accounts + (to.accountNo -> to.credit(amount))
    accounts = accounts + (from.accountNo -> from.debit(amount))
    accountsRef() = accounts
    applyTransferFees()
  }
}

dwhitney

import scala.concurrent.stm._

case class Account(accountNo: String, balance: Int){
  def credit(amount: Int) = this.copy(balance = (balance + amount))
  def debit(amount: Int) = this.copy(balance = (balance - amount))
}

object Bank{
        
  val accountsRef = Ref(Map("from" -> Account("from", 500), "to" -> Account("to", 500) ))

dwhitney

import scala.actors._
import Actor._

object Bank extends Actor{
        
  private var accounts = Map("from" -> Account("from", 500), "to" -> Account("to", 500) )
  
  def act = {
    loop{
      react{

dwhitney

import scala.actors._
import Actor._

object Bank{
        
  val accounts = Map("from" -> new Account("from", 500), "to" -> new Account("to", 500) )

  def transfer(fromNo: String, toNo: String, amount: Int): Unit = {
    val (from, to) = (accounts(fromNo), accounts(toNo))
    val balance = (from !? Balance).asInstanceOf[Int]