Synchronized Counter

Protect a shared counter update with a synchronized block.

SynchronizedCounter.scala

object Main {
  val lock = new Object()
  var counter = 0

  def add(amount: Int): Unit = {
    lock.synchronized {
      counter = counter + amount
    }
  }

  def main(args: Array[String]): Unit = {
    val amount = 

    val first = Thread(() => add(amount))
    val second = Thread(() => add(amount + 1))

    first.start()
    second.start()
    first.join()
    second.join()

    println("amount=" + amount)
    println("counter=" + counter)
  }
}

object Main {
  val lock = new Object()
  var counter = 0

  def add(amount: Int): Unit = {
    lock.synchronized {
      counter = counter + amount
    }
  }

  def main(args: Array[String]): Unit = {
    val amount = 

    val first = Thread(() => add(amount))
    val second = Thread(() => add(amount + 1))

    first.start()
    second.start()
    first.join()
    second.join()

    println("amount=" + amount)
    println("counter=" + counter)
  }
}

object Main {
  val lock = new Object()
  var counter = 0

  def add(amount: Int): Unit = {
    lock.synchronized {
      counter = counter + amount
    }
  }

  def main(args: Array[String]): Unit = {
    val amount = 

    val first = Thread(() => add(amount))
    val second = Thread(() => add(amount + 1))

    first.start()
    second.start()
    first.join()
    second.join()

    println("amount=" + amount)
    println("counter=" + counter)
  }
}

synchronized A synchronized block lets only one thread update the shared value at a time, keeping the final count predictable.