병렬 컨테이너 및 개체Parallel Containers and Objects

PPL (병렬 패턴 라이브러리)에는 해당 요소에 스레드로부터 안전한 액세스를 제공 하는 여러 컨테이너와 개체가 포함 되어 있습니다.The Parallel Patterns Library (PPL) includes several containers and objects that provide thread-safe access to their elements.

동시 컨테이너 는 가장 중요 한 작업에 대 한 동시성이 보장 된 액세스를 제공 합니다.A concurrent container provides concurrency-safe access to the most important operations. 여기서는 동시성이 안전 함을 의미 하는 포인터가 나 반복기는 항상 유효 합니다.Here, concurrency-safe means pointers or iterators are always valid. 요소 초기화 나 특정 트래버스 주문의 보장은 아닙니다.It's not a guarantee of element initialization, or of a particular traversal order. 이러한 컨테이너의 기능은 c + + 표준 라이브러리에서 제공 하는 것과 유사 합니다.The functionality of these containers resembles those that are provided by the C++ Standard Library. 예를 들어 concurrency:: concurrent_vector 클래스는 std:: vector 클래스와 유사 합니다. 단, concurrent_vector 클래스를 통해 요소를 병렬로 추가할 수 있습니다.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 concurrent containers when you have parallel code that requires both read and write access to the same container.

동시 개체 는 구성 요소 간에 동시에 공유 됩니다.A concurrent object is shared concurrently among components. 동시 개체의 상태를 병렬로 계산 하는 프로세스는 동일한 상태를 직렬로 계산 하는 다른 프로세스와 동일한 결과를 생성 합니다.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. Concurrency:: 결합할 수 있는 클래스는 동시 개체 형식의 한 예입니다.The concurrency::combinable class is one example of a concurrent object type. combinable클래스를 사용 하 여 병렬로 계산을 수행한 다음 이러한 계산을 최종 결과로 결합할 수 있습니다.The combinable class lets you perform computations in parallel, and then combine those computations into a final result. 뮤텍스와 같은 동기화 메커니즘을 사용 하 여 공유 변수 또는 리소스에 대 한 액세스를 동기화 하는 경우 동시 개체를 사용 합니다.Use concurrent objects when you would otherwise use a synchronization mechanism, for example, a mutex, to synchronize access to a shared variable or resource.

섹션이Sections

이 항목에서는 다음과 같은 병렬 컨테이너 및 개체에 대해 자세히 설명 합니다.This topic describes the following parallel containers and objects in detail.

동시 컨테이너:Concurrent containers:

동시 개체:Concurrent objects:

concurrent_vector 클래스concurrent_vector Class

Concurrency:: concurrent_vector 클래스는 std:: vector 클래스와 마찬가지로 요소에 임의로 액세스할 수 있도록 하는 시퀀스 컨테이너 클래스입니다.The concurrency::concurrent_vector class is a sequence container class that, just like the std::vector class, lets you randomly access its elements. 클래스는 동시성이 보장 되는 concurrent_vector 추가 및 요소 액세스 작업을 가능 하 게 합니다.The concurrent_vector class enables concurrency-safe append and element access operations. 추가 작업은 기존 포인터 또는 반복기를 무효화 하지 않습니다.Append operations do not invalidate existing pointers or iterators. 반복기 액세스 및 트래버스 작업도 동시성이 안전 합니다.Iterator access and traversal operations are also concurrency-safe. 여기서는 동시성이 안전 함을 의미 하는 포인터가 나 반복기는 항상 유효 합니다.Here, concurrency-safe means pointers or iterators are always valid. 요소 초기화 나 특정 트래버스 주문의 보장은 아닙니다.It's not a guarantee of element initialization, or of a particular traversal order.

Concurrent_vector와 vector의 차이점Differences Between concurrent_vector and vector

concurrent_vector클래스는 클래스와 유사 합니다 vector .The concurrent_vector class closely resembles the vector class. 개체에 대 한 추가, 요소 액세스 및 반복기 액세스 작업의 복잡성은 concurrent_vector 개체의 경우와 동일 합니다 vector .The complexity of append, element access, and iterator access operations on a concurrent_vector object are the same as for a vector object. 다음은가와 어떻게 다른 지를 보여 주는 점입니다 concurrent_vector vector .The following points illustrate where concurrent_vector differs from vector:

  • 개체에 대 한 추가, 요소 액세스, 반복기 액세스 및 반복기 순회 연산은 concurrent_vector 동시성이 보장 됩니다.Append, element access, iterator access, and iterator traversal operations on a concurrent_vector object are concurrency-safe.

  • 개체의 끝에만 요소를 추가할 수 있습니다 concurrent_vector .You can add elements only to the end of a concurrent_vector object. concurrent_vector클래스는 메서드를 제공 하지 않습니다 insert .The concurrent_vector class does not provide the insert method.

  • 개체는 추가 하는 concurrent_vector 경우 이동 의미 체계 를 사용 하지 않습니다.A concurrent_vector object does not use move semantics when you append to it.

  • concurrent_vector클래스는 또는 메서드를 제공 하지 않습니다 erase pop_back .The concurrent_vector class does not provide the erase or pop_back methods. 와 마찬가지로 vector clear 메서드를 사용 하 여 개체에서 모든 요소를 제거 concurrent_vector 합니다.As with vector, use the clear method to remove all elements from a concurrent_vector object.

  • concurrent_vector클래스는 요소를 메모리에 연속적으로 저장 하지 않습니다.The concurrent_vector class does not store its elements contiguously in memory. 따라서 concurrent_vector 배열을 사용할 수 있는 방법으로는 클래스를 사용할 수 없습니다.Therefore, you cannot use the concurrent_vector class in all the ways that you can use an array. 예를 들어 형식 이라는 변수의 경우 v concurrent_vector 식에서 &v[0]+2 정의 되지 않은 동작을 생성 합니다.For example, for a variable named v of type concurrent_vector, the expression &v[0]+2 produces undefined behavior.

  • concurrent_vector클래스는 grow_bygrow_to_at_least 메서드를 정의 합니다.The concurrent_vector class defines the grow_by and grow_to_at_least methods. 이러한 메서드는 동시성이 안전 하다는 점을 제외 하 고 resize 메서드와 유사 합니다.These methods resemble the resize method, except that they are concurrency-safe.

  • concurrent_vector개체를 추가 하거나 크기를 조정 하는 경우 개체는 해당 요소의 위치를 다시 조정 하지 않습니다.A concurrent_vector object does not relocate its elements when you append to it or resize it. 이렇게 하면 동시 작업 동안 기존 포인터 및 반복기가 유효한 상태로 유지 됩니다.This enables existing pointers and iterators to remain valid during concurrent operations.

  • 런타임은 형식에 대해의 특수화 된 버전을 정의 하지 않습니다 concurrent_vector bool .The runtime does not define a specialized version of concurrent_vector for type bool.

동시성이 안전 하 게 작동 하는 작업Concurrency-Safe Operations

개체의 크기를 추가 하거나 늘리거나 개체의 요소에 액세스 하는 모든 메서드는 concurrent_vector concurrent_vector 동시성이 안전 합니다.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. 여기서는 동시성이 안전 함을 의미 하는 포인터가 나 반복기는 항상 유효 합니다.Here, concurrency-safe means pointers or iterators are always valid. 요소 초기화 나 특정 트래버스 주문의 보장은 아닙니다.It's not a guarantee of element initialization, or of a particular traversal order. 이 규칙의 예외는 resize 메서드입니다.The exception to this rule is the resize method.

다음 표에서는 동시성이 보장 되는 일반적인 concurrent_vector 메서드 및 연산자를 보여 줍니다.The following table shows the common concurrent_vector methods and operators that are concurrency-safe.

런타임에서 c + + 표준 라이브러리와의 호환성을 위해 제공 하는 작업 (예:) reserve 은 동시성이 안전 하지 않습니다.Operations that the runtime provides for compatibility with the C++ Standard Library, for example, reserve, are not concurrency-safe. 다음 표에서는 동시성이 보장 되지 않는 일반적인 메서드 및 연산자를 보여 줍니다.The following table shows the common methods and operators that are not concurrency-safe.

기존 요소의 값을 수정 하는 연산은 동시성이 안전 하지 않습니다.Operations that modify the value of existing elements are not concurrency-safe. Reader_writer_lock 개체와 같은 동기화 개체를 사용 하 여 동일한 데이터 요소에 대 한 동시 읽기 및 쓰기 작업을 동기화 합니다.Use a synchronization object such as a reader_writer_lock object to synchronize concurrent read and write operations to the same data element. 동기화 개체에 대 한 자세한 내용은 동기화 데이터 구조를 참조 하세요.For more information about synchronization objects, see Synchronization Data Structures.

에서 사용 하는 기존 코드를 변환 하는 경우 vector concurrent_vector 동시 작업으로 인해 응용 프로그램의 동작이 변경 될 수 있습니다.When you convert existing code that uses vector to use concurrent_vector, concurrent operations can cause the behavior of your application to change. 예를 들어, 개체에서 두 개의 작업을 동시에 수행 하는 다음 프로그램이 있다고 가정 합니다 concurrent_vector .For example, consider the following program that concurrently performs two tasks on a concurrent_vector object. 첫 번째 작업은 개체에 추가 요소를 추가 합니다 concurrent_vector .The first task appends additional elements to a concurrent_vector object. 두 번째 태스크는 동일한 개체에 있는 모든 요소의 합계를 계산 합니다.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;
      }
   );
}

메서드는 end 동시성이 안전 하지만 push_back 메서드에 대 한 동시 호출로 인해에서 반환 하는 값이 end 변경 됩니다.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. 반복기가 트래버스하는 요소 수는 결정 되지 않습니다.The number of elements that the iterator traverses is indeterminate. 따라서이 프로그램은 실행 될 때마다 다른 결과를 생성할 수 있습니다.Therefore, this program can produce a different result each time that you run it. 요소 형식이 trivial이 아닌 경우 및 호출 사이에 경합 상태가 있을 수 push_back end 있습니다.When the element type is non-trivial, it's possible for a race condition to exist between push_back and end calls. end메서드는 할당 되었지만 완전히 초기화 되지 않은 요소를 반환할 수 있습니다.The end method may return an element that's allocated, but not fully initialized.

예외 안전성Exception Safety

증가 또는 할당 작업에서 예외를 throw 하는 경우 개체의 상태가 concurrent_vector 유효 하지 않게 됩니다.If a growth or assignment operation throws an exception, the state of the concurrent_vector object becomes invalid. 달리 지정 되지 concurrent_vector 않은 경우 잘못 된 상태의 개체 동작은 정의 되지 않습니다.The behavior of a concurrent_vector object that is in an invalid state is undefined unless stated otherwise. 그러나 개체의 상태가 잘못 된 경우에도 소멸자는 항상 개체가 할당 하는 메모리를 해제 합니다.However, the destructor always frees the memory that the object allocates, even if the object is in an invalid state.

벡터 요소의 데이터 형식인는 T 다음 요구 사항을 충족 해야 합니다.The data type of the vector elements, T, must meet the following requirements. 그렇지 않으면 클래스의 동작이 concurrent_vector 정의 되지 않습니다.Otherwise, the behavior of the concurrent_vector class is undefined.

  • 소멸자는를 throw 해서는 안 됩니다.The destructor must not throw.

  • 기본 생성자 또는 복사 생성자가를 throw 하는 경우 소멸자는 키워드를 사용 하 여 선언 되지 않아야 하며, 초기화 되지 않은 메모리를 사용 하 여 virtual 제대로 작동 해야 합니다.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.

[맨 위로이동][Top]

concurrent_queue 클래스concurrent_queue Class

Std:: queue 클래스와 마찬가지로 concurrency:: concurrent_queue 클래스를 사용 하 여 front 및 back 요소에 액세스할 수 있습니다.The concurrency::concurrent_queue class, just like the std::queue class, lets you access its front and back elements. 클래스는 동시성이 보장 되는 큐에 넣기 concurrent_queue 및 큐에서 제거 작업을 가능 하 게 합니다.The concurrent_queue class enables concurrency-safe enqueue and dequeue operations. 여기서는 동시성이 안전 함을 의미 하는 포인터가 나 반복기는 항상 유효 합니다.Here, concurrency-safe means pointers or iterators are always valid. 요소 초기화 나 특정 트래버스 주문의 보장은 아닙니다.It's not a guarantee of element initialization, or of a particular traversal order. concurrent_queue또한 클래스는 동시성이 안전 하지 않은 반복기 지원도 제공 합니다.The concurrent_queue class also provides iterator support that is not concurrency-safe.

Concurrent_queue와 큐의 차이점Differences Between concurrent_queue and queue

concurrent_queue클래스는 클래스와 유사 합니다 queue .The concurrent_queue class closely resembles the queue class. 다음은가와 어떻게 다른 지를 보여 주는 점입니다 concurrent_queue queue .The following points illustrate where concurrent_queue differs from queue:

  • 개체에 대 한 큐에 넣기 및 큐에서 제거 작업 concurrent_queue 은 동시성이 보장 됩니다.Enqueue and dequeue operations on a concurrent_queue object are concurrency-safe.

  • concurrent_queue클래스는 동시성이 안전 하지 않은 반복기 지원을 제공 합니다.The concurrent_queue class provides iterator support that is not concurrency-safe.

  • concurrent_queue클래스는 또는 메서드를 제공 하지 않습니다 front pop .The concurrent_queue class does not provide the front or pop methods. concurrent_queue클래스는 try_pop 메서드를 정의 하 여 이러한 메서드를 대체 합니다.The concurrent_queue class replaces these methods by defining the try_pop method.

  • concurrent_queue클래스는 메서드를 제공 하지 않습니다 back .The concurrent_queue class does not provide the back method. 따라서 큐의 끝을 참조할 수 없습니다.Therefore, you cannot reference the end of the queue.

  • concurrent_queue클래스는 메서드 대신 unsafe_size 메서드를 제공 합니다 size .The concurrent_queue class provides the unsafe_size method instead of the size method. unsafe_size메서드는 동시성이 보장 되지 않습니다.The unsafe_size method is not concurrency-safe.

동시성이 안전 하 게 작동 하는 작업Concurrency-Safe Operations

개체에서 큐에 넣기 또는 큐에서 제거 하는 모든 메서드 concurrent_queue 는 동시성이 보장 됩니다.All methods that enqueue to or dequeue from a concurrent_queue object are concurrency-safe. 여기서는 동시성이 안전 함을 의미 하는 포인터가 나 반복기는 항상 유효 합니다.Here, concurrency-safe means pointers or iterators are always valid. 요소 초기화 나 특정 트래버스 주문의 보장은 아닙니다.It's not a guarantee of element initialization, or of a particular traversal order.

다음 표에서는 동시성이 보장 되는 일반적인 concurrent_queue 메서드 및 연산자를 보여 줍니다.The following table shows the common concurrent_queue methods and operators that are concurrency-safe.

메서드는 empty 동시성이 안전 하지만, 동시 작업을 수행 하면 메서드가 반환 되기 전에 큐가 늘어나거나 줄어들 수 있습니다 empty .Although the empty method is concurrency-safe, a concurrent operation may cause the queue to grow or shrink before the empty method returns.

다음 표에서는 동시성이 보장 되지 않는 일반적인 메서드 및 연산자를 보여 줍니다.The following table shows the common methods and operators that are not concurrency-safe.

반복기 지원Iterator Support

concurrent_queue 동시성이 안전 하지 않은 반복기를 제공 합니다.The concurrent_queue provides iterators that are not concurrency-safe. 디버깅에만 이러한 반복기를 사용 하는 것이 좋습니다.We recommend that you use these iterators for debugging only.

concurrent_queue반복기는 정방향 방향 으로만 요소를 트래버스 합니다.A concurrent_queue iterator traverses elements in the forward direction only. 다음 표에서는 각 반복기가 지 원하는 연산자를 보여 줍니다.The following table shows the operators that each iterator supports.

연산자Operator 설명Description
operator++ 큐에서 다음 항목으로 이동 합니다.Advances to next item in the queue. 이 연산자는 오버 로드 된 후 위 의미 체계를 모두 제공 하도록 오버 로드 됩니다.This operator is overloaded to provide both pre-increment and post-increment semantics.
operator* 현재 항목에 대 한 참조를 검색 합니다.Retrieves a reference to the current item.
operator-> 현재 항목에 대 한 포인터를 검색 합니다.Retrieves a pointer to the current item.

[위쪽][Top]

concurrent_unordered_map 클래스concurrent_unordered_map Class

Concurrency:: concurrent_unordered_map 클래스는 std:: unordered_map 클래스와 마찬가지로 std::p air <const Key, Ty> 형식의 요소에 대 한 다양 한 길이의 요소 시퀀스를 제어 하는 결합형 컨테이너 클래스입니다.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>. 순서가 지정 되지 않은 지도는 키와 값 쌍을 추가 하거나 키로 값을 조회할 수 있는 사전으로 생각 하면 됩니다.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. 이 클래스는 공유 컨테이너에 동시에 액세스 하거나,이를 삽입 하거나, 업데이트 해야 하는 여러 스레드나 태스크가 있는 경우에 유용 합니다.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.

다음 예에서는를 사용 하기 위한 기본 구조를 보여 줍니다 concurrent_unordered_map .The following example shows the basic structure for using concurrent_unordered_map. 이 예에서는 [' a ', ' i '] 범위의 문자 키를 삽입 합니다.This example inserts character keys in the range ['a', 'i']. 작업 순서는 결정 되지 않으므로 각 키의 최종 값도 결정 되지 않습니다.Because the order of operations is undetermined, the final value for each key is also undetermined. 그러나 동시에 삽입을 수행 하는 것이 안전 합니다.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]
*/

를 사용 하 여 concurrent_unordered_map 맵을 수행 하 고 작업을 병렬로 줄이기 위해를 사용 하는 예제는 방법: 매핑 수행 및 병렬 작업 줄이기를 참조 하세요.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.

Concurrent_unordered_map와 unordered_map의 차이점Differences Between concurrent_unordered_map and unordered_map

concurrent_unordered_map클래스는 클래스와 유사 합니다 unordered_map .The concurrent_unordered_map class closely resembles the unordered_map class. 다음은가와 어떻게 다른 지를 보여 주는 점입니다 concurrent_unordered_map unordered_map .The following points illustrate where concurrent_unordered_map differs from unordered_map:

  • ,, 및 erase bucket bucket_count bucket_size 메서드의 이름은 unsafe_erase 각각,, unsafe_bucket unsafe_bucket_countunsafe_bucket_size 입니다.The erase, bucket, bucket_count, and bucket_size methods are named unsafe_erase, unsafe_bucket, unsafe_bucket_count, and unsafe_bucket_size, respectively. unsafe_명명 규칙은 이러한 메서드가 동시성이 안전 하지 않음을 나타냅니다.The unsafe_ naming convention indicates that these methods are not concurrency-safe. 동시성 안전성에 대 한 자세한 내용은 동시성 안전 작업을 참조 하세요.For more information about concurrency safety, see Concurrency-Safe Operations.

  • 삽입 작업은 기존 포인터 또는 반복기를 무효화 하지 않으며 맵에 이미 존재 하는 항목의 순서를 변경 하지도 않습니다.Insert operations do not invalidate existing pointers or iterators, nor do they change the order of items that already exist in the map. 삽입 및 트래버스 작업은 동시에 발생할 수 있습니다.Insert and traverse operations can occur concurrently.

  • concurrent_unordered_map 는 전방 반복만 지원 합니다.concurrent_unordered_map supports forward iteration only.

  • 삽입은에서 반환 하는 반복기를 무효화 하거나 업데이트 하지 않습니다 equal_range .Insertion does not invalidate or update the iterators that are returned by equal_range. 삽입은 범위의 끝에 같지 않은 항목을 추가할 수 있습니다.Insertion can append unequal items to the end of the range. Begin iterator는 동일한 항목을 가리킵니다.The begin iterator points to an equal item.

교착 상태를 방지 하기 위해의 메서드는 concurrent_unordered_map 메모리 할당자, 해시 함수 또는 기타 사용자 정의 코드를 호출할 때 잠금을 보유 하지 않습니다.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. 또한 해시 함수는 항상 동일한 키를 동일한 값으로 평가 하는지 확인 해야 합니다.Also, you must ensure that the hash function always evaluates equal keys to the same value. 최상의 해시 함수는 해시 코드 공간에서 키를 균일 하 게 분산 합니다.The best hash functions distribute keys uniformly across the hash code space.

동시성이 안전 하 게 작동 하는 작업Concurrency-Safe Operations

클래스는 동시성이 보장 되는 concurrent_unordered_map 삽입 및 요소 액세스 작업을 가능 하 게 합니다.The concurrent_unordered_map class enables concurrency-safe insert and element-access operations. 삽입 작업은 기존 포인터 또는 반복기를 무효화 하지 않습니다.Insert operations do not invalidate existing pointers or iterators. 반복기 액세스 및 트래버스 작업도 동시성이 안전 합니다.Iterator access and traversal operations are also concurrency-safe. 여기서는 동시성이 안전 함을 의미 하는 포인터가 나 반복기는 항상 유효 합니다.Here, concurrency-safe means pointers or iterators are always valid. 요소 초기화 나 특정 트래버스 주문의 보장은 아닙니다.It's not a guarantee of element initialization, or of a particular traversal order. 다음 표에서는 동시성이 보장 되는 일반적으로 사용 되는 concurrent_unordered_map 메서드 및 연산자를 보여 줍니다.The following table shows the commonly used concurrent_unordered_map methods and operators that are concurrency-safe.

동시에 count 실행 되는 스레드에서 메서드를 안전 하 게 호출할 수 있지만 새 값이 컨테이너에 동시에 삽입 되는 경우 다른 스레드가 다른 결과를 받을 수 있습니다.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.

다음 표에서는 동시성이 보장 되지 않는 일반적으로 사용 되는 메서드 및 연산자를 보여 줍니다.The following table shows the commonly used methods and operators that are not concurrency-safe.

이러한 메서드 외에도로 시작 하는 모든 메서드 unsafe_ 는 동시성이 안전 하지 않습니다.In addition to these methods, any method that begins with unsafe_ is also not concurrency-safe.

[맨 위로이동][Top]

concurrent_unordered_multimap 클래스concurrent_unordered_multimap Class

Concurrency:: concurrent_unordered_multimap 클래스는 concurrent_unordered_map 여러 값이 동일한 키에 매핑되도록 허용 한다는 점을 제외 하 고 클래스와 매우 비슷합니다.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. 또한 다음과 같은 점에서와 다릅니다 concurrent_unordered_map .It also differs from concurrent_unordered_map in the following ways:

  • Concurrent_unordered_multimap:: insert 메서드는 대신 반복기를 반환 합니다 std::pair<iterator, bool> .The concurrent_unordered_multimap::insert method returns an iterator instead of std::pair<iterator, bool>.

  • concurrent_unordered_multimap클래스는 operator[] 및 메서드를 제공 하지 않습니다 at .The concurrent_unordered_multimap class does not provide operator[] nor the at method.

다음 예에서는를 사용 하기 위한 기본 구조를 보여 줍니다 concurrent_unordered_multimap .The following example shows the basic structure for using concurrent_unordered_multimap. 이 예에서는 [' a ', ' i '] 범위의 문자 키를 삽입 합니다.This example inserts character keys in the range ['a', 'i']. concurrent_unordered_multimap 키에 여러 값을 사용할 수 있습니다.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]
*/

[맨 위로이동][Top]

concurrent_unordered_set 클래스concurrent_unordered_set Class

Concurrency:: concurrent_unordered_set 클래스는 concurrent_unordered_map 키 및 값 쌍 대신 값을 관리 한다는 점을 제외 하 고 클래스와 매우 비슷합니다.The concurrency::concurrent_unordered_set class closely resembles the concurrent_unordered_map class except that it manages values instead of key and value pairs. concurrent_unordered_set클래스는 operator[] 및 메서드를 제공 하지 않습니다 at .The concurrent_unordered_set class does not provide operator[] nor the at method.

다음 예에서는를 사용 하기 위한 기본 구조를 보여 줍니다 concurrent_unordered_set .The following example shows the basic structure for using concurrent_unordered_set. 이 예에서는 [' a ', ' i '] 범위의 문자 값을 삽입 합니다.This example inserts character values in the range ['a', 'i']. 삽입을 병렬로 수행 하는 것이 안전 합니다.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]
*/

[맨 위로이동][Top]

concurrent_unordered_multiset 클래스concurrent_unordered_multiset Class

Concurrency:: concurrent_unordered_multiset 클래스는 concurrent_unordered_set 중복 값을 허용 한다는 점을 제외 하 고 클래스와 유사 합니다.The concurrency::concurrent_unordered_multiset class closely resembles the concurrent_unordered_set class except that it allows for duplicate values. 또한 다음과 같은 점에서와 다릅니다 concurrent_unordered_set .It also differs from concurrent_unordered_set in the following ways:

  • Concurrent_unordered_multiset:: insert 메서드는 대신 반복기를 반환 합니다 std::pair<iterator, bool> .The concurrent_unordered_multiset::insert method returns an iterator instead of std::pair<iterator, bool>.

  • concurrent_unordered_multiset클래스는 operator[] 및 메서드를 제공 하지 않습니다 at .The concurrent_unordered_multiset class does not provide operator[] nor the at method.

다음 예에서는를 사용 하기 위한 기본 구조를 보여 줍니다 concurrent_unordered_multiset .The following example shows the basic structure for using concurrent_unordered_multiset. 이 예에서는 [' a ', ' i '] 범위의 문자 값을 삽입 합니다.This example inserts character values in the range ['a', 'i']. concurrent_unordered_multiset 값을 여러 번 사용할 수 있도록 합니다.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]
*/

[맨 위로이동][Top]

결합 가능한 클래스combinable Class

Concurrency:: 결합할 수 있는 클래스는 세분화 된 계산을 수행한 다음 이러한 계산을 최종 결과로 병합할 수 있는 재사용 가능한 스레드 로컬 저장소를 제공 합니다.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. combinable 개체는 환산(reduction) 변수로 간주될 수 있습니다.You can think of a combinable object as a reduction variable.

combinable클래스는 여러 스레드나 작업 간에 공유 되는 리소스가 있는 경우에 유용 합니다.The combinable class is useful when you have a resource that is shared among several threads or tasks. combinable클래스를 사용 하면 잠금 없는 방식으로 공유 리소스에 대 한 액세스를 제공 하 여 공유 상태를 제거할 수 있습니다.The combinable class helps you eliminate shared state by providing access to shared resources in a lock-free manner. 따라서이 클래스는 뮤텍스와 같은 동기화 메커니즘을 사용 하 여 여러 스레드의 공유 데이터에 대 한 액세스를 동기화 하는 대신 사용할 수 있는 방법을 제공 합니다.Therefore, this class provides an alternative to using a synchronization mechanism, for example, a mutex, to synchronize access to shared data from multiple threads.

메서드 및 기능Methods and Features

다음 표에서는 클래스의 몇 가지 중요 한 메서드를 보여 줍니다 combinable .The following table shows some of the important methods of the combinable class. 모든 클래스 메서드에 대 한 자세한 내용은 combinable 결합 가능한 클래스를 참조 하세요.For more information about all the combinable class methods, see combinable Class.

메서드Method 설명Description
로컬local 현재 스레드 컨텍스트와 연결 된 지역 변수에 대 한 참조를 검색 합니다.Retrieves a reference to the local variable that is associated with the current thread context.
해제clear 개체에서 모든 스레드 지역 변수를 제거 합니다 combinable .Removes all thread-local variables from the combinable object.
결합combine

combine_eachcombine_each
제공 된 combine 함수를 사용 하 여 모든 스레드 로컬 계산 집합에서 최종 값을 생성 합니다.Uses the provided combine function to generate a final value from the set of all thread-local computations.

combinable클래스는 병합 된 최종 결과에 매개 변수화 된 템플릿 클래스입니다.The combinable class is a template class that is parameterized on the final merged result. 기본 생성자를 호출 하는 경우 T 템플릿 매개 변수 형식에는 기본 생성자와 복사 생성자가 있어야 합니다.If you call the default constructor, the T template parameter type must have a default constructor and a copy constructor. T템플릿 매개 변수 형식에 기본 생성자가 없는 경우 초기화 함수를 매개 변수로 사용 하는 생성자의 오버 로드 된 버전을 호출 합니다.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.

combinable Combine 또는 combine_each 메서드를 호출한 후에는 개체에 추가 데이터를 저장할 수 있습니다.You can store additional data in a combinable object after you call the combine or combine_each methods. combine및 메서드를 여러 번 호출할 수도 있습니다 combine_each .You can also call the combine and combine_each methods multiple times. 개체에 로컬 값이 변경 되지 않은 경우 combinable combinecombine_each 메서드는 호출 될 때마다 동일한 결과를 생성 합니다.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.

Examples

클래스를 사용 하는 방법에 대 한 예제는 combinable 다음 항목을 참조 하세요.For examples about how to use the combinable class, see the following topics:

[맨 위로이동][Top]

방법: 병렬 컨테이너를 사용 하 여 효율성 향상How to: Use Parallel Containers to Increase Efficiency
병렬 컨테이너를 사용 하 여 효율적으로 데이터를 효율적으로 저장 하 고 액세스 하는 방법을 보여 줍니다.Shows how to use parallel containers to efficiently store and access data in parallel.

방법: 결합을 사용 하 여 성능 향상How to: Use combinable to Improve Performance
클래스를 사용 하 여 combinable 공유 상태를 제거 하 여 성능을 향상 시키는 방법을 보여 줍니다.Shows how to use the combinable class to eliminate shared state, and thereby improve performance.

방법: 조합 하 여 집합 결합How to: Use combinable to Combine Sets
함수를 사용 하 여 combine 스레드 로컬 데이터 집합을 병합 하는 방법을 보여 줍니다.Shows how to use a combine function to merge thread-local sets of data.

PPL(병렬 패턴 라이브러리)Parallel Patterns Library (PPL)
동시 응용 프로그램을 개발 하기 위한 확장성과 사용 편의성을 향상 시키는 명령형 프로그래밍 모델을 제공 하는 PPL에 대해 설명 합니다.Describes the PPL, which provides an imperative programming model that promotes scalability and ease-of-use for developing concurrent applications.

참조Reference

concurrent_vector 클래스concurrent_vector Class

concurrent_queue 클래스concurrent_queue Class

concurrent_unordered_map 클래스concurrent_unordered_map Class

concurrent_unordered_multimap 클래스concurrent_unordered_multimap Class

concurrent_unordered_set 클래스concurrent_unordered_set Class

concurrent_unordered_multiset 클래스concurrent_unordered_multiset Class

결합 가능한 클래스combinable Class