首先來一個生產者消費者的例子：

Producer：

  class Producer(drop : Drop) 
    extends Runnable 
  { 
    val importantInfo : Array[String] = Array( 
      "Mares eat oats", 
      "Does eat oats", 
      "Little lambs eat ivy", 
      "A kid will eat ivy too"
    ); 
  
    override def run() : Unit = 
    { 
      importantInfo.foreach((msg) => drop.put(msg)) 
      drop.put("DONE") 
    } 
  } 
 

  class Consumer(drop : Drop) 
    extends Runnable 
  { 
    override def run() : Unit = 
    { 
      var message = drop.take() 
      while (message != "DONE") 
      { 
        System.out.format("MESSAGE RECEIVED: %s%n", message) 
        message = drop.take() 
      } 
    } 
  } 

 class Drop 
  { 
    var message : String = ""
    var empty : Boolean = true 
    var lock : AnyRef = new Object() 
  
    def put(x: String) : Unit = 
      lock.synchronized 
      { 
        // Wait until message has been retrieved 
        await (empty == true) 
        // Toggle status 
        empty = false 
        // Store message 
        message = x 
        // Notify consumer that status has changed 
        lock.notifyAll() 
      } 

    def take() : String = 
      lock.synchronized 
      { 
        // Wait until message is available. 
        await (empty == false) 
        // Toggle status 
        empty=true 
        // Notify producer that staus has changed 
        lock.notifyAll() 
        // Return the message 
        message 
      } 

    private def await(cond: => Boolean) = 
      while (!cond) { lock.wait() } 
  } 
 

object ProdConSample 
 { 
  def main(args : Array[String]) : Unit = 
  { 
    // Create Drop 
    val drop = new Drop(); 
  
    // Spawn Producer 
    new Thread(new Producer(drop)).start(); 
    
    // Spawn Consumer 
    new Thread(new Consumer(drop)).start(); 
  } 
 }

Producer和 Consumer類幾乎與它們的 Java 同類相同，再一次擴充套件（實現）了 Runnable

Drop類同樣類似於它的 Java 版本。但 Scala 中有一些例外，“synchronized” 並不是關鍵字，它是針對 AnyRef類定義的一個方法，即 Scala “所有引用型別的根”。這意味著，要同步某個特定的物件，您只需要對該物件呼叫同步方法；在本例中，對 Drop上的 lock 欄位中所儲存的物件呼叫同步方法。

注意，我們在 await()方法定義的 Drop類中還利用了一種 Scala 機制：cond引數是等待計算的程式碼塊，而不是在傳遞給該方法之前進行計算。在 Scala 中，這被稱作 “call-by-name”；此處，它是一種實用的方法，可以捕獲需要在 Java 版本中表示兩次的條件等待邏輯（分別用於 put和take）。

最後，在 main()中，建立 Drop例項，例項化兩個執行緒，使用 start()啟動它們，然後在 main()的結束部分退出，相信 JVM 會在 main()結束之前啟動這兩個執行緒。（在生產程式碼中，可能無法保證這種情況，但對於這樣的簡單的例子，99.99 ％ 沒有問題。）

但是，已經說過，仍然存在相同的基本問題：程式設計師仍然需要過分擔心兩個執行緒之間的通訊和協調問題。雖然一些 Scala 機制可以簡化語法，但這目前為止並沒有相當大的吸引力

Scala 併發性 v2

Scala Library Reference 中有一個有趣的包：scala.concurrency。這個包包含許多不同的併發性結構，包括我們即將利用的 MailBox類。

顧名思義，MailBox從本質上說就是 Drop，用於在檢測之前儲存資料塊的單槽緩衝區。但是，MailBox最大的優勢在於它將傳送和接收資料的細節完全封裝到模式匹配和 case 類中，這使它比簡單的 Drop（或 Drop的多槽資料儲存類 java.util.concurrent.BoundedBuffer）更加靈活。

 package com.tedneward.scalaexamples.scala.V2 
 { 
  import concurrent.{MailBox, ops} 

  object ProdConSample 
  { 
    class Producer(drop : Drop) 
      extends Runnable 
    { 
      val importantInfo : Array[String] = Array( 
        "Mares eat oats", 
        "Does eat oats", 
        "Little lambs eat ivy", 
        "A kid will eat ivy too"
      ); 
    
      override def run() : Unit = 
      { 
        importantInfo.foreach((msg) => drop.put(msg)) 
        drop.put("DONE") 
      } 
    } 
    
    class Consumer(drop : Drop) 
      extends Runnable 
    { 
      override def run() : Unit = 
      { 
        var message = drop.take() 
        while (message != "DONE") 
        { 
          System.out.format("MESSAGE RECEIVED: %s%n", message) 
          message = drop.take() 
        } 
      } 
    } 

    class Drop 
    { 
      private val m = new MailBox() 
      
      private case class Empty() 
      private case class Full(x : String) 
      
      m send Empty()  // initialization 
      
      def put(msg : String) : Unit = 
      { 
        m receive 
        { 
          case Empty() => 
            m send Full(msg) 
        } 
      } 
      
      def take() : String = 
      { 
        m receive 
        { 
          case Full(msg) => 
            m send Empty(); msg 
        } 
      } 
    } 
  
    def main(args : Array[String]) : Unit = 
    { 
      // Create Drop 
      val drop = new Drop() 
      
      // Spawn Producer 
      new Thread(new Producer(drop)).start(); 
      
      // Spawn Consumer 
      new Thread(new Consumer(drop)).start(); 
    } 
  } 
 }

此處，v2 和 v1 之間的惟一區別在於 Drop的實現，它現在利用 MailBox類處理傳入以及從 Drop中刪除的訊息的阻塞和訊號事務。（我們可以重寫 Producer和 Consumer，讓它們直接使用 MailBox，但考慮到簡單性，我們假定希望保持所有示例中的 DropAPI 相一致。）使用 MailBox與使用典型的 BoundedBuffer（Drop）稍有不同，因此我們來仔細看看其程式碼。

MailBox有兩個基本操作：send和 receive。receiveWithin 方法僅僅是基於超時的 receive。MailBox接收任何型別的訊息。send()方法將訊息放置到郵箱中，並立即通知任何關心該型別訊息的等待接收者，並將它附加到一個訊息連結串列中以便稍後檢索。receive()方法將阻塞，直到接收到對於功能塊合適的訊息。

因此，在這種情況下，我們將建立兩個 case 類，一個不包含任何內容（Empty），這表示 MailBox為空，另一個包含訊息資料（Full。

• put方法，由於它會將資料放置在 Drop中，對 MailBox呼叫 receive()以查詢 Empty例項，因此會阻塞直到傳送 Empty。此時，它傳送一個Full例項給包含新資料的 MailBox。
• take方法，由於它會從 Drop中刪除資料，對 MailBox呼叫 receive()以查詢 Full例項，提取訊息（再次得益於模式匹配從 case 類內部提取值並將它們綁到本地變數的能力）併發送一個 Empty 例項給 MailBox。

不需要明確的鎖定，並且不需要考慮監控程式。

Scala 併發性 v3

事實上，我們可以顯著縮短程式碼，只要 Producer 和 Consumer不需要功能全面的類（此處便是如此） —兩者從本質上說都是 Runnable.run()方法的瘦包裝器，Scala 可以使用 scala.concurrent.ops物件的 spawn方法來實現

 package com.tedneward.scalaexamples.scala.V3 
 { 
  import concurrent.MailBox 
  import concurrent.ops._ 

  object ProdConSample 
  { 
    class Drop 
    { 
      private val m = new MailBox() 
      
      private case class Empty() 
      private case class Full(x : String) 
      
      m send Empty()  // initialization 
      
      def put(msg : String) : Unit = 
      { 
        m receive 
        { 
          case Empty() => 
            m send Full(msg) 
        } 
      } 
      
      def take() : String = 
      { 
        m receive 
        { 
          case Full(msg) => 
            m send Empty(); msg 
        } 
      } 
    } 
  
    def main(args : Array[String]) : Unit = 
    { 
      // Create Drop 
      val drop = new Drop() 
      
      // Spawn Producer 
      spawn 
      { 
        val importantInfo : Array[String] = Array( 
          "Mares eat oats", 
          "Does eat oats", 
          "Little lambs eat ivy", 
          "A kid will eat ivy too"
        ); 
        
        importantInfo.foreach((msg) => drop.put(msg)) 
        drop.put("DONE") 
      } 
      
      // Spawn Consumer 
      spawn 
      { 
        var message = drop.take() 
        while (message != "DONE") 
        { 
          System.out.format("MESSAGE RECEIVED: %s%n", message) 
          message = drop.take() 
        } 
      } 
    } 
  } 
 }

<span style="background-color: rgb(153, 153, 153);">  def spawn(p: => Unit) = { 
    val t = new Thread() { override def run() = p } 
    t.start() 
  }</span>