The `scala.collection.concurrent.Map` trait is _not meant to be mixed-in_ with an existing mutable Scala `Map` to obtain a thread-safe version of the map instance. The `SynchronizedMap` mixin existed for this purpose before `2.11`, but is now deprecated.

Currently, Scala has the `scala.collection.concurrent.TrieMap` implementation for the `scala.collection.concurrent.Map` interface, but can wrap Java classes as well.

The `scala.collection.concurrent.Map`, in versions prior to 2.10 known as `scala.collection.mutable.ConcurrentMap`, interface is used when you:

- want to implement your own concurrent, thread-safe `Map` from scratch

- want to wrap an existing Java concurrent map implementation:

E.g:

    import scala.collection._
    import scala.collection.convert.decorateAsScala._
    import java.util.concurrent.ConcurrentHashMap

    val map: concurrent.Map[String, String] = new ConcurrentHashMap().asScala

- want to write generic code that works concurrent maps, and don't want to commit to a specific implementation:

E.g.:

    import scala.collection._

    def foo(map: concurrent.Map[String, String]) = map.putIfAbsent("", "")

    foo(new concurrent.TrieMap)
    foo(new java.util.concurrent.ConcurrentSkipListMap().asScala)

- you could implement your own wrapper around a single-threaded mutable map implementation by using synchronized (but you would need to ensure that your program is accessing the mutable map only through this wrapper and never directly).

E.g.:

    class MySynchronizedMap[K, V](private val underlying: mutable.Map[K, V])
    extends concurrent.Map[K, V] {
      private val monitor = new AnyRef
      def putIfAbsent(k: K,v: V): Option[String] = monitor.synchronized {
        underlying.get(k) match {
          case s: Some[V] => s
          case None =>
            underlying(k) = v
            None
        }
      }
      def remove(k: K, v: V): Boolean = monitor.synchronized {
        underlying.get(k) match {
          case Some(v0) if v == v0 => underlying.remove(k); true
          case None => false
        }
      }
      // etc.
    }