Пакет scala.collection.parallel.mutable

пакет mutable

Источник: package.scala

Линейные супертипы

Члены типов

трайт LazyCombiner[Elem, +To, Buff <: Growable[Elem] with Sizing] extends Combiner[Elem, To]

Реализует объединение содержимого двух комбинирующих элементов, откладывая операцию до вызова метода result. Он связывает результаты листьев вместе, вместо вычисления фактического набора.

Elem: тип элементов в комбинирующем элементе
To: тип набора, который производит комбинирующий элемент
Buff: тип буферов, которые содержат результаты листьев, и этот комбинирующий элемент связывает вместе

класс ParArray[T] extends ParSeq[T] with GenericParTemplate[T, ParArray] with ParSeqLike[T, ParArray[T], ArraySeq[T]] with Serializable

Параллельная последовательность, содержащая элементы в линейном массиве.

ParArray является параллельной последовательностью с предопределенным размером. Размер массива нельзя изменить после его создания.

ParArray внутренне хранит массив, содержащий элементы. Это означает, что операции по объему, основанные на обходе, обеспечивают быстрый доступ к элементам. ParArray использует ленивые генераторы, которые создают внутренний массив данных только после того, как размер массива станет известен. Тем временем они сохраняют фрагментированный результат. Фрагменты копируются в результирующий массив данных параллельно с помощью быстрых операций копирования массивов, как только все комбинирующие элементы будут заполнены параллельно.

T: тип элементов в массиве

Annotations: @SerialVersionUID()
Since: 2.9
См. также: Обзор библиотеки параллельных наборов Scala раздел по ParArray для получения дополнительной информации.

тип ParArrayCombiner[T] = ResizableParArrayCombiner[T]

трайт ParFlatHashTable[T] extends FlatHashTable[T]

Параллельная плоская хэш-таблица.

T: тип элементов в таблице.

класс ParHashMap[K, V] extends ParMap[K, V] with GenericParMapTemplate[K, V, ParHashMap] with ParMapLike[K, V, ParHashMap[K, V], HashMap[K, V]] with ParHashTable[K, DefaultEntry[K, V]] with Serializable

Параллельный хэш-мап.

ParHashMap — это параллельный мап, который внутренне хранит элементы в хэш-таблице. Он использует цепочки для разрешения коллизий.

K: тип ключей в параллельном хэш-мапе
V: тип значений в параллельном хэш-мапе

Annotations: @SerialVersionUID()

класс ParHashSet[T] extends ParSet[T] with GenericParTemplate[T, ParHashSet] with ParSetLike[T, ParHashSet[T], HashSet[T]] with ParFlatHashTable[T] with Serializable

Параллельный хэш-сет.

ParHashSet — это параллельный сет, который внутренне хранит элементы в хэш-таблице. Он использует линейное зондирование для разрешения коллизий.

T: тип элементов в параллельном хэш-сете.

Annotations: @SerialVersionUID()

трайт ParHashTable[K, Entry >: Null <: HashEntry[K, Entry]] extends HashTable[K, Entry]

трайт ParIterable[T] extends GenIterable[T] with parallel.ParIterable[T] with GenericParTemplate[T, ParIterable] with ParIterableLike[T, ParIterable[T], Iterable[T]] with Mutable

Шаблонный трайт для изменяемых параллельных итерируемых коллекций.

Это базовый трайт для параллельных коллекций Scala. Он определяет поведение, общее для всех параллельных коллекций. Конкретные параллельные коллекции должны наследовать этот трайт и ParIterable если они хотят определить специфические фабрики комбинирования.

Параллельные операции реализуются с помощью алгоритмов типа «разделяй и властвуй», которые хорошо масштабируются по параллелизму. Основная идея заключается в разделении коллекции на меньшие части до тех пор, пока они не станут достаточно малыми для последовательной обработки.

def splitter: IterableSplitter[T]

который возвращает экземпляр IterableSplitter[T], который является подтипом Splitter[T]. Разделители имеют метод remaining для проверки оставшегося количества элементов и метод split, который определяется разделителями. Метод split делит итерируемые разделителями на непересекающиеся подмножества:

def split: Seq[Splitter]

который разбивает разделитель на последовательность непересекающихся подразделителей. Обычно это очень быстрая операция, которая просто создаёт обёртки вокруг исходной коллекции. Это можно повторять рекурсивно.

Задачи планируются для выполнения через объект scala.collection.parallel.TaskSupport, который можно изменить через tasksupport коллекцию.

Метод newCombiner производит новый комбинирователь. Комбинирователи являются расширением билдеров. Они предоставляют метод combine который объединяет два комбинирователя и возвращает комбинирователь, содержащий элементы обоих комбинирователей. Этот метод может быть реализован путём агрессивного копирования всех элементов в новый комбинирователь или путём ленивой привязки их результатов. Рекомендуется избегать копирования всех элементов по причинам производительности, хотя эта стоимость может быть незначительной в зависимости от конкретного случая. Стандартные параллельные коллекции комбинирователи избегают копирования при слиянии результатов, полагаясь либо на двухэтапную ленивую конструкцию, либо на свойства конкретной структуры данных.

Методы:

def seq: Sequential
def par: Repr

соответственно производят последовательную или параллельную реализацию коллекции. Метод par просто возвращает ссылку на эту параллельную коллекцию. Метод seq является эффективным — он не будет копировать элементы. Вместо этого он создаст последовательную версию коллекции, используя ту же основную структуру данных. Обратите внимание, что это не относится к последовательным коллекциям в общем случае — они могут скопировать элементы и произвести другую основную структуру данных.

Сочетание методов toMap, toSeq или toSet вместе с par и seq является гибким способом изменения между различными типами коллекций.

Поскольку этот трайт расширяет трайт GenIterable, методы, такие как size, также должны быть реализованы в конкретных коллекциях, в то время как iterator по умолчанию перенаправляет вызовы на splitter.

Каждая параллельная коллекция связана со специфическим пулом fork/join, в котором хранятся неактивные рабочие потоки. Пул fork/join содержит другую информацию, например, уровень параллелизма, то есть количество используемых процессоров. При создании коллекции ей назначается стандартный пул fork/join, находящийся в scala.parallel пакете.

Параллельные коллекции не обязательно упорядочены с точки зрения операции foreach (см. Traversable). Параллельные последовательности имеют хорошо определённый порядок для итераторов — создание итератора и линейное прохождение элементов всегда дадут одинаковый порядок. Однако массовые операции, такие как foreach, map или filter всегда происходят в неопределённом порядке для всех параллельных коллекций.

Существующие реализации параллельных коллекций предоставляют жёсткие параллельные итераторы. Строгие параллельные итераторы знают количество элементов, которые им ещё предстоит пройти. Также возможно предоставить нестрогие параллельные итераторы, которые не знают количество оставшихся элементов. Для этого новая реализация коллекции должна переопределить isStrictSplitterCollection на false. Это сделает некоторые операции недоступными.

Чтобы создать новую параллельную коллекцию, расширьте трайт ParIterable и реализуйте size, splitter, newCombiner и seq. Использование неявной фабрики комбинирователей требует расширения этого трайта, а также предоставления объекта компаньона, как и для обычных коллекций.

Метод size реализован как операция постоянного времени для параллельных коллекций, и параллельные операции коллекций полагаются на это предположение.

Функции высшего порядка, переданные в определённые операции, могут содержать побочные эффекты. Поскольку реализации массовых операций могут не быть последовательными, это означает, что побочные эффекты могут быть непредсказуемыми и могут привести к гонкам данных, тупикам или некорректности состояния, если не принять соответствующие меры. Программист должен либо избегать использования побочных эффектов, либо использовать некоторую форму синхронизации при доступе к изменяемым данным.

T: тип элементов коллекции

Since: 2.9

трайт ParMap[K, V] extends GenMap[K, V] with parallel.ParMap[K, V] with ParIterable[(K, V)] with GenericParMapTemplate[K, V, ParMap] with ParMapLike[K, V, ParMap[K, V], mutable.Map[K, V]]

Шаблонный интерфейс для изменяемых параллельных словарей.

Функции высшего порядка, передаваемые некоторым операциям, могут содержать побочные эффекты. Поскольку реализации массовых операций могут не быть последовательными, это означает, что побочные эффекты могут быть непредсказуемыми и могут привести к гонкам данных, тупикам или недействительности состояния, если не соблюдать осторожность. Программист должен либо избегать использования побочных эффектов, либо использовать какую-либо форму синхронизации при доступе к изменяемым данным.

K: тип ключа словаря
V: тип значения словаря

Since: 2.9

trait ParMapLike[K, V, +Repr <: ParMapLike[K, V, Repr, Sequential] with ParMap[K, V], +Sequential <: mutable.Map[K, V] with mutable.MapLike[K, V, Sequential]] extends GenMapLike[K, V, Repr] with parallel.ParMapLike[K, V, Repr, Sequential] with Growable[(K, V)] with Shrinkable[K] with mutable.Cloneable[Repr]

Шаблонный интерфейс для изменяемых параллельных словарей. Этот интерфейс должен быть смешан с конкретными параллельными словарями для переопределения типа представления.

K: тип ключа словаря
V: тип значения словаря

trait ParSeq[T] extends GenSeq[T] with ParIterable[T] with parallel.ParSeq[T] with GenericParTemplate[T, ParSeq] with ParSeqLike[T, ParSeq[T], mutable.Seq[T]]

trait ParSet[T] extends GenSet[T] with ParIterable[T] with parallel.ParSet[T] with GenericParTemplate[T, ParSet] with ParSetLike[T, ParSet[T], mutable.Set[T]]

trait ParSetLike[T, +Repr <: ParSetLike[T, Repr, Sequential] with ParSet[T], +Sequential <: mutable.Set[T] with mutable.SetLike[T, Sequential]] extends GenSetLike[T, Repr] with ParIterableLike[T, Repr, Sequential] with parallel.ParSetLike[T, Repr, Sequential] with Growable[T] with Shrinkable[T] with mutable.Cloneable[Repr]

Шаблонный трайт для изменяемых параллельных множеств. Этот трайт смешивается с конкретными параллельными множествами для переопределения типа представления.

Функции высшего порядка, передаваемые некоторым операциям, могут содержать побочные эффекты. Поскольку реализации массовых операций могут не быть последовательными, это означает, что побочные эффекты могут быть непредсказуемыми и могут привести к гонкам данных, тупикам или аннулированию состояния, если не соблюдать осторожность. Программист должен либо избегать использования побочных эффектов, либо использовать какие-либо средства синхронизации при доступе к изменяемым данным.

T: тип элементов множества

final class ParTrieMap[K, V] extends ParMap[K, V] with GenericParMapTemplate[K, V, ParTrieMap] with ParMapLike[K, V, ParTrieMap[K, V], TrieMap[K, V]] with ParTrieMapCombiner[K, V] with Serializable

Параллельное TrieMap коллекция.

Её массовые операции выполняются параллельно, но для создания разделителя используется операция создания снимка. Это означает, что параллельные массовые операции могут вызываться одновременно с изменениями.

Since: 2.10
См. также: Обзор библиотеки параллельных коллекций Scala раздел о ParTrieMap для получения дополнительной информации.

trait ResizableParArrayCombiner[T] extends LazyCombiner[T, ParArray[T], ExposedArrayBuffer[T]]

trait UnrolledParArrayCombiner[T] extends Combiner[T, ParArray[T]]

Члены-значения

val ParArrayCombiner: ResizableParArrayCombiner.type

object ParArray extends ParFactory[ParArray] with Serializable

object ParHashMap extends ParMapFactory[ParHashMap] with Serializable

object ParHashSet extends ParSetFactory[ParHashSet] with Serializable

object ParIterable extends ParFactory[ParIterable]

object ParMap extends ParMapFactory[ParMap]

object ParSeq extends ParFactory[ParSeq]

object ParSet extends ParSetFactory[ParSet]

object ParTrieMap extends ParMapFactory[ParTrieMap] with Serializable

object ResizableParArrayCombiner

object UnrolledParArrayCombiner

© 2002-2019 EPFL, with contributions from Lightbend.
Licensed under the Apache License, Version 2.0.
https://www.scala-lang.org/api/2.12.9/scala/collection/parallel/mutable/index.html