Scala Standard Library 2.13.16 - scala.collection.concurrent
Keywords: Scala Standard Library 2.13.16 scala.collection.concurrent

Scala Standard Library2.13.16 < Back


# Packages

-  package root

  This is the documentation for the Scala standard library.

  This is the documentation for the Scala standard library.

  #### Package structure

  The scala package contains core types like `Int`, `Float`, `Array` or `Option` which are accessible in all Scala compilation units without explicit qualification or imports.

  Notable packages include:

  - `scala.collection` and its sub-packages contain Scala's collections framework
    - `scala.collection.immutable` - Immutable, sequential data-structures such as `Vector`, `List`, `Range`, `HashMap` or `HashSet`
    - `scala.collection.mutable` - Mutable, sequential data-structures such as `ArrayBuffer`, `StringBuilder`, `HashMap` or `HashSet`
    - `scala.collection.concurrent` - Mutable, concurrent data-structures such as `TrieMap`
  - `scala.concurrent` - Primitives for concurrent programming such as `Futures` and `Promises`
  - `scala.io` - Input and output operations
  - `scala.math` - Basic math functions and additional numeric types like `BigInt` and `BigDecimal`
  - `scala.sys` - Interaction with other processes and the operating system
  - `scala.util.matching` - Regular expressions

  Other packages exist. See the complete list on the right.

  Additional parts of the standard library are shipped as separate libraries. These include:

  - `scala.reflect` - Scala's reflection API (scala-reflect.jar)
  - `scala.xml` - XML parsing, manipulation, and serialization (scala-xml.jar)
  - `scala.collection.parallel` - Parallel collections (scala-parallel-collections.jar)
  - `scala.util.parsing` - Parser combinators (scala-parser-combinators.jar)
  - `scala.swing` - A convenient wrapper around Java's GUI framework called Swing (scala-swing.jar)

  #### Automatic imports

  Identifiers in the scala package and the `scala.Predef` object are always in scope by default.

  Some of these identifiers are type aliases provided as shortcuts to commonly used classes. For example, `List` is an alias for `scala.collection.immutable.List`.

  Other aliases refer to classes provided by the underlying platform. For example, on the JVM, `String` is an alias for `java.lang.String`.

  Definition Classes
    root
-  package scala

  Core Scala types.

  Core Scala types. They are always available without an explicit import.

  Definition Classes
    root
-  package collection
  Definition Classes
    scala
-  package concurrent
  Definition Classes
    collection
- Map
- TrieMap
-  package convert
  Definition Classes
    collection
-  package generic
  Definition Classes
    collection
-  package immutable
  Definition Classes
    collection
-  package mutable
  Definition Classes
    collection

p

scala.collection

# concurrent

#### package concurrent

Content Hierarchy

Ordering

1. Alphabetic

Visibility

1. Public
2. Protected

### Type Members

1.  trait Map[K, V] extends mutable.Map[K, V]

   A template trait for mutable maps that allow concurrent access.

   A template trait for mutable maps that allow concurrent access.

   This is a base trait for all Scala concurrent map implementations. It provides all of the methods a `Map` does, with the difference that all the changes are atomic. It also describes methods specific to concurrent maps.

   K

     the key type of the map

   V

     the value type of the map

   See also

     "Scala's Collection Library overview" section on `Concurrent Maps` for more information.

2.  final class TrieMap[K, V] extends mutable.AbstractMap[K, V] with Map[K, V] with mutable.MapOps[K, V, TrieMap, TrieMap[K, V]] with MapFactoryDefaults[K, V, TrieMap, mutable.Iterable] with DefaultSerializable

   A concurrent hash-trie or TrieMap is a concurrent thread-safe lock-free implementation of a hash array mapped trie.

   A concurrent hash-trie or TrieMap is a concurrent thread-safe lock-free implementation of a hash array mapped trie. It is used to implement the concurrent map abstraction. It has particularly scalable concurrent insert and remove operations and is memory-efficient. It supports O(1), atomic, lock-free snapshots which are used to implement linearizable lock-free size, iterator and clear operations. The cost of evaluating the (lazy) snapshot is distributed across subsequent updates, thus making snapshot evaluation horizontally scalable.

   For details, see: http://lampwww.epfl.ch/~prokopec/ctries-snapshot.pdf

   Annotations
     @SerialVersionUID()

### Value Members

1.  object TrieMap extends MapFactory[TrieMap]
   Annotations
     @SerialVersionUID()

### Ungrouped