Contenedores y objetos paralelosParallel Containers and Objects

La biblioteca de patrones de procesamiento paralelo (PPL) incluye varios contenedores y objetos que proporcionan acceso seguro para subprocesos a sus elementos.The Parallel Patterns Library (PPL) includes several containers and objects that provide thread-safe access to their elements.

Un contenedor simultáneo proporciona acceso seguro para simultaneidad a las operaciones más importantes.A concurrent container provides concurrency-safe access to the most important operations. Aquí, la seguridad de simultaneidad significa que los punteros o iteradores siempre son válidos.Here, concurrency-safe means pointers or iterators are always valid. No es una garantía de la inicialización de elementos o de un orden de cruce determinado.It's not a guarantee of element initialization, or of a particular traversal order. La funcionalidad de estos contenedores es similar a la proporcionada por la biblioteca estándar de C++.The functionality of these containers resembles those that are provided by the C++ Standard Library. Por ejemplo, la clase Concurrency:: concurrent_vector es similar a la clase STD:: Vector , salvo que la concurrent_vector clase permite anexar elementos en paralelo.For example, the concurrency::concurrent_vector class resembles the std::vector class, except that the concurrent_vector class lets you append elements in parallel. Use contenedores simultáneos cuando tenga código paralelo que requiera acceso de lectura y escritura al mismo contenedor.Use concurrent containers when you have parallel code that requires both read and write access to the same container.

Un objeto simultáneo se comparte simultáneamente entre los componentes.A concurrent object is shared concurrently among components. Un proceso que calcula el estado de un objeto simultáneo en paralelo produce el mismo resultado que otro proceso que calcula el mismo estado en serie.A process that computes the state of a concurrent object in parallel produces the same result as another process that computes the same state serially. La clase Concurrency:: combinable es un ejemplo de un tipo de objeto simultáneo.The concurrency::combinable class is one example of a concurrent object type. La combinable clase le permite realizar cálculos en paralelo y, a continuación, combinar esos cálculos en un resultado final.The combinable class lets you perform computations in parallel, and then combine those computations into a final result. Use objetos simultáneos cuando, de lo contrario, usaría un mecanismo de sincronización, por ejemplo, una exclusión mutua, para sincronizar el acceso a una variable o un recurso compartido.Use concurrent objects when you would otherwise use a synchronization mechanism, for example, a mutex, to synchronize access to a shared variable or resource.

SecciónSections

En este tema se describen los siguientes contenedores y objetos paralelos en detalle.This topic describes the following parallel containers and objects in detail.

Contenedores simultáneos:Concurrent containers:

Objetos simultáneos:Concurrent objects:

concurrent_vector (clase)concurrent_vector Class

La clase Concurrency:: concurrent_vector es una clase de contenedor de secuencias que, al igual que la clase STD:: Vector , permite tener acceso de forma aleatoria a sus elementos.The concurrency::concurrent_vector class is a sequence container class that, just like the std::vector class, lets you randomly access its elements. La concurrent_vector clase habilita las operaciones de anexión y acceso a elementos con seguridad de simultaneidad.The concurrent_vector class enables concurrency-safe append and element access operations. Las operaciones de anexión no invalidan los punteros o iteradores existentes.Append operations do not invalidate existing pointers or iterators. El acceso a iterador y las operaciones de recorrido también son seguras para simultaneidad.Iterator access and traversal operations are also concurrency-safe. Aquí, la seguridad de simultaneidad significa que los punteros o iteradores siempre son válidos.Here, concurrency-safe means pointers or iterators are always valid. No es una garantía de la inicialización de elementos o de un orden de cruce determinado.It's not a guarantee of element initialization, or of a particular traversal order.

Diferencias entre concurrent_vector y VectorDifferences Between concurrent_vector and vector

La concurrent_vector clase es muy similar a la vector clase.The concurrent_vector class closely resembles the vector class. La complejidad de las operaciones append, acceso a elementos y acceso a iterador en un concurrent_vector objeto es igual que para un vector objeto.The complexity of append, element access, and iterator access operations on a concurrent_vector object are the same as for a vector object. Los puntos siguientes muestran dónde concurrent_vector difiere de vector :The following points illustrate where concurrent_vector differs from vector:

  • Append, acceso a elementos, acceso a iterador y las operaciones de recorrido de iterador en un concurrent_vector objeto son seguras para simultaneidad.Append, element access, iterator access, and iterator traversal operations on a concurrent_vector object are concurrency-safe.

  • Solo puede agregar elementos al final de un concurrent_vector objeto.You can add elements only to the end of a concurrent_vector object. La concurrent_vector clase no proporciona el insert método.The concurrent_vector class does not provide the insert method.

  • Un concurrent_vector objeto no utiliza la semántica de movimiento cuando se anexa a él.A concurrent_vector object does not use move semantics when you append to it.

  • La concurrent_vector clase no proporciona los erase métodos o pop_back .The concurrent_vector class does not provide the erase or pop_back methods. Como con vector , use el método Clear para quitar todos los elementos de un concurrent_vector objeto.As with vector, use the clear method to remove all elements from a concurrent_vector object.

  • La concurrent_vector clase no almacena sus elementos de forma contigua en la memoria.The concurrent_vector class does not store its elements contiguously in memory. Por lo tanto, no se puede utilizar la concurrent_vector clase en todas las formas en que se puede utilizar una matriz.Therefore, you cannot use the concurrent_vector class in all the ways that you can use an array. Por ejemplo, para una variable denominada v de tipo concurrent_vector , la expresión &v[0]+2 produce un comportamiento indefinido.For example, for a variable named v of type concurrent_vector, the expression &v[0]+2 produces undefined behavior.

  • La concurrent_vector clase define los métodos grow_by y grow_to_at_least .The concurrent_vector class defines the grow_by and grow_to_at_least methods. Estos métodos son similares al método de cambio de tamaño , con la salvedad de que son seguros para simultaneidad.These methods resemble the resize method, except that they are concurrency-safe.

  • Un concurrent_vector objeto no reubica sus elementos al anexarlo o cambiar su tamaño.A concurrent_vector object does not relocate its elements when you append to it or resize it. Esto permite que los punteros e iteradores existentes sigan siendo válidos durante las operaciones simultáneas.This enables existing pointers and iterators to remain valid during concurrent operations.

  • El runtime no define una versión especializada de concurrent_vector para el tipo bool .The runtime does not define a specialized version of concurrent_vector for type bool.

Operaciones seguras para simultaneidadConcurrency-Safe Operations

Todos los métodos que anexan o aumentan el tamaño de un concurrent_vector objeto, o tienen acceso a un elemento de un concurrent_vector objeto, son seguros para simultaneidad.All methods that append to or increase the size of a concurrent_vector object, or access an element in a concurrent_vector object, are concurrency-safe. Aquí, la seguridad de simultaneidad significa que los punteros o iteradores siempre son válidos.Here, concurrency-safe means pointers or iterators are always valid. No es una garantía de la inicialización de elementos o de un orden de cruce determinado.It's not a guarantee of element initialization, or of a particular traversal order. La excepción a esta regla es el resize método.The exception to this rule is the resize method.

En la tabla siguiente se muestran los concurrent_vector métodos y los operadores comunes que son seguros para simultaneidad.The following table shows the common concurrent_vector methods and operators that are concurrency-safe.

Las operaciones que el motor en tiempo de ejecución proporciona para la compatibilidad con la biblioteca estándar de C++, por ejemplo,, reserve no son seguras para simultaneidad.Operations that the runtime provides for compatibility with the C++ Standard Library, for example, reserve, are not concurrency-safe. En la tabla siguiente se muestran los métodos y operadores comunes que no son seguros para simultaneidad.The following table shows the common methods and operators that are not concurrency-safe.

Las operaciones que modifican el valor de los elementos existentes no son seguras para simultaneidad.Operations that modify the value of existing elements are not concurrency-safe. Use un objeto de sincronización, como un objeto reader_writer_lock para sincronizar las operaciones de lectura y escritura simultáneas en el mismo elemento de datos.Use a synchronization object such as a reader_writer_lock object to synchronize concurrent read and write operations to the same data element. Para obtener más información sobre los objetos de sincronización, vea Synchronization Data Structures.For more information about synchronization objects, see Synchronization Data Structures.

Al convertir el código existente que usa vector para usar concurrent_vector , las operaciones simultáneas pueden hacer que el comportamiento de la aplicación cambie.When you convert existing code that uses vector to use concurrent_vector, concurrent operations can cause the behavior of your application to change. Por ejemplo, considere el siguiente programa que realiza simultáneamente dos tareas en un concurrent_vector objeto.For example, consider the following program that concurrently performs two tasks on a concurrent_vector object. La primera tarea anexa elementos adicionales a un concurrent_vector objeto.The first task appends additional elements to a concurrent_vector object. La segunda tarea calcula la suma de todos los elementos del mismo objeto.The second task computes the sum of all elements in the same object.

// parallel-vector-sum.cpp
// compile with: /EHsc
#include <ppl.h>
#include <concurrent_vector.h>
#include <iostream>

using namespace concurrency;
using namespace std;

int wmain()
{
   // Create a concurrent_vector object that contains a few
   // initial elements.
   concurrent_vector<int> v;
   v.push_back(2);
   v.push_back(3);
   v.push_back(4);
   
   // Perform two tasks in parallel.
   // The first task appends additional elements to the concurrent_vector object.
   // The second task computes the sum of all elements in the same object.

   parallel_invoke(
      [&v] { 
         for(int i = 0; i < 10000; ++i)
         {
            v.push_back(i);
         }
      },
      [&v] {
         combinable<int> sums;
         for(auto i = begin(v); i != end(v); ++i) 
         {
            sums.local() += *i;
         }     
         wcout << L"sum = " << sums.combine(plus<int>()) << endl;
      }
   );
}

Aunque el end método es seguro para simultaneidad, una llamada simultánea al método push_back hace que el valor devuelto por end cambie.Although the end method is concurrency-safe, a concurrent call to the push_back method causes the value that is returned by end to change. El número de elementos que el iterador atraviesa es indeterminado.The number of elements that the iterator traverses is indeterminate. Por lo tanto, este programa puede generar un resultado diferente cada vez que se ejecuta.Therefore, this program can produce a different result each time that you run it. Cuando el tipo de elemento no es trivial, es posible que exista una condición de carrera entre las push_back end llamadas y.When the element type is non-trivial, it's possible for a race condition to exist between push_back and end calls. El end método puede devolver un elemento que está asignado, pero que no está completamente inicializado.The end method may return an element that's allocated, but not fully initialized.

Seguridad de excepcionesException Safety

Si una operación de crecimiento o asignación produce una excepción, el estado del concurrent_vector objeto deja de ser válido.If a growth or assignment operation throws an exception, the state of the concurrent_vector object becomes invalid. El comportamiento de un concurrent_vector objeto que se encuentra en un estado no válido es undefined, a menos que se indique lo contrario.The behavior of a concurrent_vector object that is in an invalid state is undefined unless stated otherwise. Sin embargo, el destructor siempre libera la memoria que el objeto asigna, incluso si el objeto está en un estado no válido.However, the destructor always frees the memory that the object allocates, even if the object is in an invalid state.

El tipo de datos de los elementos vectoriales, T , debe cumplir los siguientes requisitos.The data type of the vector elements, T, must meet the following requirements. De lo contrario, el comportamiento de la concurrent_vector clase es indefinido.Otherwise, the behavior of the concurrent_vector class is undefined.

  • El destructor no debe iniciar.The destructor must not throw.

  • Si el constructor predeterminado o de copia inicia, el destructor no debe declararse mediante la virtual palabra clave y debe funcionar correctamente con memoria inicializada en cero.If the default or copy constructor throws, the destructor must not be declared by using the virtual keyword and it must work correctly with zero-initialized memory.

[Arriba][Top]

concurrent_queue (clase)concurrent_queue Class

La clase Concurrency:: concurrent_queue , al igual que la clase STD:: Queue , permite tener acceso a sus elementos delante y detrás.The concurrency::concurrent_queue class, just like the std::queue class, lets you access its front and back elements. La concurrent_queue clase habilita las operaciones de puesta en cola y eliminación de la cola con seguridad de simultaneidad.The concurrent_queue class enables concurrency-safe enqueue and dequeue operations. Aquí, la seguridad de simultaneidad significa que los punteros o iteradores siempre son válidos.Here, concurrency-safe means pointers or iterators are always valid. No es una garantía de la inicialización de elementos o de un orden de cruce determinado.It's not a guarantee of element initialization, or of a particular traversal order. La concurrent_queue clase también proporciona compatibilidad de iterador que no es segura para simultaneidad.The concurrent_queue class also provides iterator support that is not concurrency-safe.

Diferencias entre concurrent_queue y QueueDifferences Between concurrent_queue and queue

La concurrent_queue clase es muy similar a la queue clase.The concurrent_queue class closely resembles the queue class. Los puntos siguientes muestran dónde concurrent_queue difiere de queue :The following points illustrate where concurrent_queue differs from queue:

  • Las operaciones enqueue y dequeue en un concurrent_queue objeto son seguras para simultaneidad.Enqueue and dequeue operations on a concurrent_queue object are concurrency-safe.

  • La concurrent_queue clase proporciona compatibilidad de iterador que no es segura para simultaneidad.The concurrent_queue class provides iterator support that is not concurrency-safe.

  • La concurrent_queue clase no proporciona los front métodos o pop .The concurrent_queue class does not provide the front or pop methods. La concurrent_queue clase reemplaza estos métodos definiendo el método try_pop .The concurrent_queue class replaces these methods by defining the try_pop method.

  • La concurrent_queue clase no proporciona el back método.The concurrent_queue class does not provide the back method. Por lo tanto, no se puede hacer referencia al final de la cola.Therefore, you cannot reference the end of the queue.

  • La concurrent_queue clase proporciona el método unsafe_size en lugar del size método.The concurrent_queue class provides the unsafe_size method instead of the size method. El unsafe_size método no es seguro para simultaneidad.The unsafe_size method is not concurrency-safe.

Operaciones seguras para simultaneidadConcurrency-Safe Operations

Todos los métodos que se ponen en cola o se quitan de la cola de un concurrent_queue objeto son seguros para simultaneidad.All methods that enqueue to or dequeue from a concurrent_queue object are concurrency-safe. Aquí, la seguridad de simultaneidad significa que los punteros o iteradores siempre son válidos.Here, concurrency-safe means pointers or iterators are always valid. No es una garantía de la inicialización de elementos o de un orden de cruce determinado.It's not a guarantee of element initialization, or of a particular traversal order.

En la tabla siguiente se muestran los concurrent_queue métodos y los operadores comunes que son seguros para simultaneidad.The following table shows the common concurrent_queue methods and operators that are concurrency-safe.

Aunque el empty método es seguro para simultaneidad, una operación simultánea puede hacer que la cola crezca o se reduzca antes de que el empty método devuelva.Although the empty method is concurrency-safe, a concurrent operation may cause the queue to grow or shrink before the empty method returns.

En la tabla siguiente se muestran los métodos y operadores comunes que no son seguros para simultaneidad.The following table shows the common methods and operators that are not concurrency-safe.

Compatibilidad con iteradoresIterator Support

concurrent_queueProporciona iteradores que no son seguros para simultaneidad.The concurrent_queue provides iterators that are not concurrency-safe. Se recomienda usar estos iteradores solo para la depuración.We recommend that you use these iterators for debugging only.

Un concurrent_queue iterador atraviesa los elementos solo en la dirección hacia delante.A concurrent_queue iterator traverses elements in the forward direction only. En la tabla siguiente se muestran los operadores que admite cada iterador.The following table shows the operators that each iterator supports.

OperadorOperator DescripciónDescription
operator++ Avanza al siguiente elemento de la cola.Advances to next item in the queue. Este operador se sobrecarga para proporcionar la semántica de incremento previo y posterior al incremento.This operator is overloaded to provide both pre-increment and post-increment semantics.
operator* Recupera una referencia al elemento actual.Retrieves a reference to the current item.
operator-> Recupera un puntero al elemento actual.Retrieves a pointer to the current item.

[Superior][Top]

concurrent_unordered_map (clase)concurrent_unordered_map Class

La clase Concurrency:: concurrent_unordered_map es una clase de contenedor asociativo que, al igual que la clase std:: unordered_map , controla una secuencia de elementos de longitud variable de tipo STD: <const Key, Ty> :p Air.The concurrency::concurrent_unordered_map class is an associative container class that, just like the std::unordered_map class, controls a varying-length sequence of elements of type std::pair<const Key, Ty>. Piense en un mapa no ordenado como un diccionario en el que puede Agregar un par clave-valor o buscar un valor por clave.Think of an unordered map as a dictionary that you can add a key and value pair to or look up a value by key. Esta clase es útil cuando hay varios subprocesos o tareas que tienen que acceder simultáneamente a un contenedor compartido, insertar en él o actualizarlo.This class is useful when you have multiple threads or tasks that have to concurrently access a shared container, insert into it, or update it.

En el ejemplo siguiente se muestra la estructura básica para usar concurrent_unordered_map .The following example shows the basic structure for using concurrent_unordered_map. En este ejemplo se insertan claves de caracteres en el intervalo [' a ', ' i '].This example inserts character keys in the range ['a', 'i']. Dado que el orden de las operaciones es indeterminado, el valor final de cada clave también es indeterminado.Because the order of operations is undetermined, the final value for each key is also undetermined. Sin embargo, es seguro realizar las inserciones en paralelo.However, it is safe to perform the insertions in parallel.

// unordered-map-structure.cpp
// compile with: /EHsc
#include <ppl.h>
#include <concurrent_unordered_map.h>
#include <iostream>

using namespace concurrency;
using namespace std;

int wmain() 
{
    //
    // Insert a number of items into the map in parallel.

    concurrent_unordered_map<char, int> map; 

    parallel_for(0, 1000, [&map](int i) {
        char key = 'a' + (i%9); // Geneate a key in the range [a,i].
        int value = i;          // Set the value to i.
        map.insert(make_pair(key, value));
    });

    // Print the elements in the map.
    for_each(begin(map), end(map), [](const pair<char, int>& pr) {
        wcout << L"[" << pr.first << L", " << pr.second << L"] ";
    });
}
/* Sample output:
    [e, 751] [i, 755] [a, 756] [c, 758] [g, 753] [f, 752] [b, 757] [d, 750] [h, 754]
*/

Para obtener un ejemplo que usa concurrent_unordered_map para realizar una operación de asignación y reducción en paralelo, vea Cómo: realizar operaciones de asignación y reducción en paralelo.For an example that uses concurrent_unordered_map to perform a map and reduce operation in parallel, see How to: Perform Map and Reduce Operations in Parallel.

Diferencias entre concurrent_unordered_map y unordered_mapDifferences Between concurrent_unordered_map and unordered_map

La concurrent_unordered_map clase es muy similar a la unordered_map clase.The concurrent_unordered_map class closely resembles the unordered_map class. Los puntos siguientes muestran dónde concurrent_unordered_map difiere de unordered_map :The following points illustrate where concurrent_unordered_map differs from unordered_map:

  • Los erase bucket métodos,, y bucket_count bucket_size se denominan unsafe_erase , unsafe_bucket , unsafe_bucket_count y unsafe_bucket_size , respectivamente.The erase, bucket, bucket_count, and bucket_size methods are named unsafe_erase, unsafe_bucket, unsafe_bucket_count, and unsafe_bucket_size, respectively. La unsafe_ Convención de nomenclatura indica que estos métodos no son seguros para simultaneidad.The unsafe_ naming convention indicates that these methods are not concurrency-safe. Para obtener más información sobre la seguridad de simultaneidad, consulte operaciones seguras de simultaneidad.For more information about concurrency safety, see Concurrency-Safe Operations.

  • Las operaciones de inserción no invalidan los punteros o iteradores existentes, ni cambian el orden de los elementos que ya existen en el mapa.Insert operations do not invalidate existing pointers or iterators, nor do they change the order of items that already exist in the map. Las operaciones de inserción y recorrido se pueden producir simultáneamente.Insert and traverse operations can occur concurrently.

  • concurrent_unordered_map solo admite la iteración hacia delante.concurrent_unordered_map supports forward iteration only.

  • La inserción no invalida ni actualiza los iteradores devueltos por equal_range .Insertion does not invalidate or update the iterators that are returned by equal_range. La inserción puede anexar elementos distintos al final del intervalo.Insertion can append unequal items to the end of the range. El iterador inicial apunta a un elemento igual.The begin iterator points to an equal item.

Para ayudar a evitar el interbloqueo, ningún método de concurrent_unordered_map mantiene un bloqueo cuando llama al asignador de memoria, a las funciones hash u otro código definido por el usuario.To help avoid deadlock, no method of concurrent_unordered_map holds a lock when it calls the memory allocator, hash functions, or other user-defined code. Además, debe asegurarse de que la función hash siempre evalúa las mismas claves con el mismo valor.Also, you must ensure that the hash function always evaluates equal keys to the same value. Las mejores funciones hash distribuyen las claves uniformemente en el espacio de código hash.The best hash functions distribute keys uniformly across the hash code space.

Operaciones seguras para simultaneidadConcurrency-Safe Operations

La concurrent_unordered_map clase habilita las operaciones de inserción y acceso a elementos seguras para simultaneidad.The concurrent_unordered_map class enables concurrency-safe insert and element-access operations. Las operaciones de inserción no invalidan los punteros o iteradores existentes.Insert operations do not invalidate existing pointers or iterators. El acceso a iterador y las operaciones de recorrido también son seguras para simultaneidad.Iterator access and traversal operations are also concurrency-safe. Aquí, la seguridad de simultaneidad significa que los punteros o iteradores siempre son válidos.Here, concurrency-safe means pointers or iterators are always valid. No es una garantía de la inicialización de elementos o de un orden de cruce determinado.It's not a guarantee of element initialization, or of a particular traversal order. En la tabla siguiente se muestran los concurrent_unordered_map métodos y los operadores de uso frecuente que son seguros para simultaneidad.The following table shows the commonly used concurrent_unordered_map methods and operators that are concurrency-safe.

Aunque count se puede llamar al método de forma segura a partir de subprocesos que se ejecutan simultáneamente, los distintos subprocesos pueden recibir resultados diferentes si se inserta un nuevo valor al mismo tiempo en el contenedor.Although the count method can be called safely from concurrently running threads, different threads can receive different results if a new value is simultaneously inserted into the container.

En la tabla siguiente se muestran los métodos y operadores usados comúnmente que no son seguros para simultaneidad.The following table shows the commonly used methods and operators that are not concurrency-safe.

Además de estos métodos, cualquier método que empiece por unsafe_ tampoco es seguro para simultaneidad.In addition to these methods, any method that begins with unsafe_ is also not concurrency-safe.

[Arriba][Top]

concurrent_unordered_multimap (clase)concurrent_unordered_multimap Class

La clase Concurrency:: concurrent_unordered_multimap es muy similar a la concurrent_unordered_map clase, salvo que permite que varios valores se asignen a la misma clave.The concurrency::concurrent_unordered_multimap class closely resembles the concurrent_unordered_map class except that it allows for multiple values to map to the same key. También difiere de de concurrent_unordered_map las maneras siguientes:It also differs from concurrent_unordered_map in the following ways:

  • El método concurrent_unordered_multimap:: Insert devuelve un iterador en lugar de std::pair<iterator, bool> .The concurrent_unordered_multimap::insert method returns an iterator instead of std::pair<iterator, bool>.

  • La concurrent_unordered_multimap clase no proporciona operator[] ni el at método.The concurrent_unordered_multimap class does not provide operator[] nor the at method.

En el ejemplo siguiente se muestra la estructura básica para usar concurrent_unordered_multimap .The following example shows the basic structure for using concurrent_unordered_multimap. En este ejemplo se insertan claves de caracteres en el intervalo [' a ', ' i '].This example inserts character keys in the range ['a', 'i']. concurrent_unordered_multimap habilita una clave para que tenga varios valores.concurrent_unordered_multimap enables a key to have multiple values.

// unordered-multimap-structure.cpp
// compile with: /EHsc
#include <ppl.h>
#include <concurrent_unordered_map.h>
#include <iostream>

using namespace concurrency;
using namespace std;

int wmain() 
{
    //
    // Insert a number of items into the map in parallel.

    concurrent_unordered_multimap<char, int> map; 

    parallel_for(0, 10, [&map](int i) {
        char key = 'a' + (i%9); // Geneate a key in the range [a,i].
        int value = i;          // Set the value to i.
        map.insert(make_pair(key, value));
    });

    // Print the elements in the map.
    for_each(begin(map), end(map), [](const pair<char, int>& pr) {
        wcout << L"[" << pr.first << L", " << pr.second << L"] ";
    });
}
/* Sample output:
    [e, 4] [i, 8] [a, 9] [a, 0] [c, 2] [g, 6] [f, 5] [b, 1] [d, 3] [h, 7]
*/

[Arriba][Top]

concurrent_unordered_set (clase)concurrent_unordered_set Class

La clase Concurrency:: concurrent_unordered_set es muy similar concurrent_unordered_map a la clase, salvo que administra los valores en lugar de los pares clave-valor.The concurrency::concurrent_unordered_set class closely resembles the concurrent_unordered_map class except that it manages values instead of key and value pairs. La concurrent_unordered_set clase no proporciona operator[] ni el at método.The concurrent_unordered_set class does not provide operator[] nor the at method.

En el ejemplo siguiente se muestra la estructura básica para usar concurrent_unordered_set .The following example shows the basic structure for using concurrent_unordered_set. En este ejemplo se insertan valores de caracteres en el intervalo [' a ', ' i '].This example inserts character values in the range ['a', 'i']. Es seguro realizar las inserciones en paralelo.It is safe to perform the insertions in parallel.

// unordered-set-structure.cpp
// compile with: /EHsc
#include <ppl.h>
#include <concurrent_unordered_set.h>
#include <iostream>

using namespace concurrency;
using namespace std;

int wmain() 
{
    //
    // Insert a number of items into the set in parallel.

    concurrent_unordered_set<char> set; 

    parallel_for(0, 10000, [&set](int i) {
        set.insert('a' + (i%9)); // Geneate a value in the range [a,i].
    });

    // Print the elements in the set.
    for_each(begin(set), end(set), [](char c) {
        wcout << L"[" << c << L"] ";
    });
}
/* Sample output:
    [e] [i] [a] [c] [g] [f] [b] [d] [h]
*/

[Arriba][Top]

concurrent_unordered_multiset (clase)concurrent_unordered_multiset Class

La clase Concurrency:: concurrent_unordered_multiset es muy similar concurrent_unordered_set a la clase, salvo que permite valores duplicados.The concurrency::concurrent_unordered_multiset class closely resembles the concurrent_unordered_set class except that it allows for duplicate values. También difiere de de concurrent_unordered_set las maneras siguientes:It also differs from concurrent_unordered_set in the following ways:

  • El método concurrent_unordered_multiset:: Insert devuelve un iterador en lugar de std::pair<iterator, bool> .The concurrent_unordered_multiset::insert method returns an iterator instead of std::pair<iterator, bool>.

  • La concurrent_unordered_multiset clase no proporciona operator[] ni el at método.The concurrent_unordered_multiset class does not provide operator[] nor the at method.

En el ejemplo siguiente se muestra la estructura básica para usar concurrent_unordered_multiset .The following example shows the basic structure for using concurrent_unordered_multiset. En este ejemplo se insertan valores de caracteres en el intervalo [' a ', ' i '].This example inserts character values in the range ['a', 'i']. concurrent_unordered_multiset permite que un valor se produzca varias veces.concurrent_unordered_multiset enables a value to occur multiple times.

// unordered-set-structure.cpp
// compile with: /EHsc
#include <ppl.h>
#include <concurrent_unordered_set.h>
#include <iostream>

using namespace concurrency;
using namespace std;

int wmain() 
{
    //
    // Insert a number of items into the set in parallel.

    concurrent_unordered_multiset<char> set; 

    parallel_for(0, 40, [&set](int i) {
        set.insert('a' + (i%9)); // Geneate a value in the range [a,i].
    });

    // Print the elements in the set.
    for_each(begin(set), end(set), [](char c) {
        wcout << L"[" << c << L"] ";
    });
}
/* Sample output:
    [e] [e] [e] [e] [i] [i] [i] [i] [a] [a] [a] [a] [a] [c] [c] [c] [c] [c] [g] [g]
    [g] [g] [f] [f] [f] [f] [b] [b] [b] [b] [b] [d] [d] [d] [d] [d] [h] [h] [h] [h]
*/

[Arriba][Top]

combinable (clase)combinable Class

La clase Concurrency:: combinable proporciona almacenamiento local de subprocesos reutilizable que permite realizar cálculos específicos y, a continuación, combinar esos cálculos en un resultado final.The concurrency::combinable class provides reusable, thread-local storage that lets you perform fine-grained computations and then merge those computations into a final result. Puede pensar en un objeto combinable como una variable de reducción.You can think of a combinable object as a reduction variable.

La combinable clase resulta útil cuando se tiene un recurso compartido entre varios subprocesos o tareas.The combinable class is useful when you have a resource that is shared among several threads or tasks. La combinable clase ayuda a eliminar el estado compartido al proporcionar acceso a los recursos compartidos sin bloqueos.The combinable class helps you eliminate shared state by providing access to shared resources in a lock-free manner. Por lo tanto, esta clase proporciona una alternativa al uso de un mecanismo de sincronización, por ejemplo, una exclusión mutua, para sincronizar el acceso a los datos compartidos desde varios subprocesos.Therefore, this class provides an alternative to using a synchronization mechanism, for example, a mutex, to synchronize access to shared data from multiple threads.

Métodos y característicasMethods and Features

En la tabla siguiente se muestran algunos de los métodos importantes de la combinable clase.The following table shows some of the important methods of the combinable class. Para obtener más información acerca de todos los combinable métodos de clase, vea clase combinable.For more information about all the combinable class methods, see combinable Class.

MétodoMethod DescripciónDescription
localizarlocal Recupera una referencia a la variable local que está asociada al contexto del subproceso actual.Retrieves a reference to the local variable that is associated with the current thread context.
clearclear Quita todas las variables locales del subproceso del combinable objeto.Removes all thread-local variables from the combinable object.
Combínelocombine

combine_eachcombine_each
Usa la función de combinación proporcionada para generar un valor final a partir del conjunto de todos los cálculos locales de subprocesos.Uses the provided combine function to generate a final value from the set of all thread-local computations.

La combinable clase es una clase de plantilla que se parametriza en el resultado final combinado.The combinable class is a template class that is parameterized on the final merged result. Si llama al constructor predeterminado, el T tipo de parámetro de plantilla debe tener un constructor predeterminado y un constructor de copias.If you call the default constructor, the T template parameter type must have a default constructor and a copy constructor. Si el T tipo de parámetro de plantilla no tiene un constructor predeterminado, llame a la versión sobrecargada del constructor que toma una función de inicialización como su parámetro.If the T template parameter type does not have a default constructor, call the overloaded version of the constructor that takes an initialization function as its parameter.

Puede almacenar datos adicionales en un combinable objeto después de llamar a los métodos combine o combine_each .You can store additional data in a combinable object after you call the combine or combine_each methods. También puede llamar a los combine combine_each métodos y varias veces.You can also call the combine and combine_each methods multiple times. Si no cambia ningún valor local en un combinable objeto, combine los combine_each métodos y producen el mismo resultado cada vez que se llaman.If no local value in a combinable object changes, the combine and combine_each methods produce the same result every time that they are called.

EjemplosExamples

Para obtener ejemplos sobre cómo usar la combinable clase, vea los temas siguientes:For examples about how to use the combinable class, see the following topics:

[Arriba][Top]

Cómo: usar contenedores paralelos para aumentar la eficaciaHow to: Use Parallel Containers to Increase Efficiency
Muestra cómo usar contenedores paralelos para almacenar y obtener acceso a los datos en paralelo de forma eficaz.Shows how to use parallel containers to efficiently store and access data in parallel.

Cómo: usar la clase combinable para mejorar el rendimientoHow to: Use combinable to Improve Performance
Muestra cómo utilizar la combinable clase para eliminar el estado compartido y, por tanto, mejorar el rendimiento.Shows how to use the combinable class to eliminate shared state, and thereby improve performance.

Cómo: usar la clase combinable para combinar conjuntosHow to: Use combinable to Combine Sets
Muestra cómo utilizar una combine función para combinar conjuntos de datos locales de subprocesos.Shows how to use a combine function to merge thread-local sets of data.

Parallel Patterns Library (PPL)Parallel Patterns Library (PPL)
Describe la biblioteca PPL, que proporciona un modelo de programación imperativo que promueve la escalabilidad y la facilidad de uso para desarrollar aplicaciones simultáneas.Describes the PPL, which provides an imperative programming model that promotes scalability and ease-of-use for developing concurrent applications.

ReferenciaReference

concurrent_vector (clase)concurrent_vector Class

concurrent_queue (clase)concurrent_queue Class

concurrent_unordered_map (clase)concurrent_unordered_map Class

concurrent_unordered_multimap (clase)concurrent_unordered_multimap Class

concurrent_unordered_set (clase)concurrent_unordered_set Class

concurrent_unordered_multiset (clase)concurrent_unordered_multiset Class

combinable (clase)combinable Class