Paralel Kapsayıcılar ve Nesneler

Paralel Desenler Kitaplığı (PPL), öğelerine iş parçacığı güvenli erişim sağlayan çeşitli kapsayıcılar ve nesneler içerir.

Eşzamanlı kapsayıcı , en önemli işlemlere eşzamanlılık açısından güvenli erişim sağlar. Burada eşzamanlılık açısından güvenli, işaretçilerin veya yineleyicilerin her zaman geçerli olduğu anlamına gelir. Bu, öğe başlatmanın veya belirli bir dolaşma sırasının garantisi değildir. Bu kapsayıcıların işlevselliği, C++ Standart Kitaplığı tarafından sağlananlara benzer. Örneğin, eşzamanlılık::concurrent_vector sınıfı, std::vector sınıfına benzer, ancak concurrent_vector sınıfı, öğeleri paralel olarak eklemenize olanak tanır. Aynı kapsayıcıya hem okuma hem de yazma erişimi gerektiren paralel kodunuz olduğunda eşzamanlı kapsayıcıları kullanın.

Eşzamanlı bir nesne bileşenler arasında eşzamanlı olarak paylaşılır. Eşzamanlı bir nesnenin durumunu paralel olarak hesaplayan bir işlem, aynı durumu seri olarak hesaplayan başka bir işlemle aynı sonucu verir. concurrency::combinable sınıfı, eş zamanlı nesne türünün bir örneğidir. sınıfı, combinable hesaplamaları paralel olarak gerçekleştirmenize ve ardından bu hesaplamaları nihai bir sonuç olarak birleştirmenize olanak tanır. Aksi takdirde, paylaşılan bir değişkene veya kaynağa erişimi eşzamanlı hale getirmek için bir eşitleme mekanizması (örneğin, bir mutex) kullanacağınız durumlarda eşzamanlı nesneler kullanın.

Bölümler

Bu konu başlığında aşağıdaki paralel kapsayıcılar ve nesneler ayrıntılı olarak açıklanmaktadır.

Eşzamanlı kapsayıcılar:

• concurrent_vector Sınıfı

  • concurrent_vector ve vektör arasındaki farklar

  • Eşzamanlılık-Güvenli İşlemler

  • Özel Durum Güvenliği

• concurrent_queue Sınıfı

  • concurrent_queue ile kuyruk arasındaki farklar

  • Eşzamanlılık-Güvenli İşlemler

  • Yineleyici Desteği

• concurrent_unordered_map Sınıfı

  • concurrent_unordered_map ile unordered_map Arasındaki Farklar

  • Eşzamanlılık-Güvenli İşlemler

• concurrent_unordered_multimap Sınıfı

• concurrent_unordered_set Sınıfı

• concurrent_unordered_multiset Sınıfı

Eşzamanlı nesneler:

• Birleştirilebilir Sınıf

  • Yöntemler ve Özellikler

  • Örnekler

concurrent_vector Sınıfı

concurrency::concurrent_vector sınıfı, std::vector sınıfı gibi öğelerine rastgele erişmenizi sağlayan bir dizi kapsayıcı sınıfıdır. concurrent_vector sınıfı, eşzamanlı güvenli ekleme ve eleman erişim işlemlerini etkinleştirir. Ekleme işlemleri mevcut işaretçileri veya yineleyicileri geçersiz kılmaz. Yineleyici erişimi ve dolaşma işlemleri de eşzamanlılık açısından güvenlidir. Burada eşzamanlılık açısından güvenli, işaretçilerin veya yineleyicilerin her zaman geçerli olduğu anlamına gelir. Bu, öğe başlatmanın veya belirli bir dolaşma sırasının garantisi değildir.

concurrent_vector ve vector arasındaki farklar

concurrent_vector sınıfı, vector sınıfına çok benzer. Bir nesnedeki concurrent_vector ekleme, öğe erişimi ve yineleyici erişim işlemlerinin karmaşıklığı nesneyle vector aynıdır. Aşağıdaki noktalar concurrent_vector ile vector arasındaki farkları gösterir:

• Bir concurrent_vector nesnedeki ekleme, öğe erişimi, yineleyici erişimi ve yineleyici geçiş işlemleri eşzamanlılık açısından güvenlidir.

• Yalnızca nesnenin concurrent_vector sonuna öğe ekleyebilirsiniz. concurrent_vector sınıfı insert yöntemini sağlamaz.

• Nesneye concurrent_vector eklerken taşıma semantiği kullanmaz.

• The correct translation should read: concurrent_vector sınıfı erase veya pop_back yöntemini sağlamaz. vector ile olduğu gibi, bir concurrent_vector nesnesinden tüm öğeleri kaldırmak için clear yöntemini kullanın.

• concurrent_vector sınıfı, öğelerini bitişik olarak bellekte depolamaz. Bu nedenle, sınıfını concurrent_vector bir diziyi kullanabileceğiniz tüm yollarla kullanamazsınız. Örneğin, türünde vadlı concurrent_vector bir değişken için ifade &v[0]+2 tanımsız davranış üretir.

• sınıf, concurrent_vectorgrow_by ve grow_to_at_least yöntemlerini tanımlar. Bu yöntemler, eşzamanlılık açısından güvenli olmaları dışında yeniden boyutlandırma yöntemine benzer.

• Bir concurrent_vector nesne, öğelerine eklediğinizde veya yeniden boyutlandırdığınızda öğelerini yeniden taşımaz. Bu, mevcut işaretçilerin ve yineleyicilerin eşzamanlı işlemler sırasında geçerli kalmasını sağlar.

• Çalışma zamanı concurrent_vector türü için bool özel bir sürümünü tanımlamaz.

Eşzamanlılık-Güvenli İşlemler

Bir nesnenin sonuna eklenen veya nesnenin boyutunu artıran ya da nesnedeki concurrent_vectorconcurrent_vector bir öğeye erişen tüm yöntemler eşzamanlılık açısından güvenlidir. Burada eşzamanlılık açısından güvenli, işaretçilerin veya yineleyicilerin her zaman geçerli olduğu anlamına gelir. Bu, öğe başlatmanın veya belirli bir dolaşma sırasının garantisi değildir. Bu kuralın özel durumu yöntemidir resize .

Aşağıdaki tabloda eşzamanlılık açısından güvenli olan yaygın concurrent_vector yöntemler ve işleçler gösterilmektedir.

at
back
begin
capacity

empty
end
front
grow_by

grow_to_at_least
max_size
operator[]
push_back

rbegin
rend
size

Çalışma zamanının C++ Standart Kitaplığı ile uyumluluk için sağladığı işlemler (örneğin, reserve) eşzamanlılık açısından güvenli değildir. Aşağıdaki tabloda eşzamanlılık açısından güvenli olmayan yaygın yöntemler ve işleçler gösterilmektedir.

assign
clear

operator=
reserve

resize

shrink_to_fit

Mevcut öğelerin değerini değiştiren işlemler eşzamanlılık açısından güvenli değildir. Eşzamanlı okuma ve yazma işlemlerini aynı veri öğesiyle eşitlemek için reader_writer_lock nesnesi gibi bir eşitleme nesnesi kullanın. Eşitleme nesneleri hakkında daha fazla bilgi için bkz . Eşitleme Veri Yapıları.

Mevcut vector kodunu concurrent_vector kullanarak dönüştürdüğünüzde, eşzamanlı işlemler uygulamanızın davranışının değişmesine neden olabilir. Örneğin, bir concurrent_vector nesne üzerinde iki görevi eşzamanlı olarak gerçekleştiren aşağıdaki programı göz önünde bulundurun. İlk görev bir concurrent_vector nesneye ek öğeler ekler. İkinci görev, aynı nesnedeki tüm öğelerin toplamını hesaplar.

// 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;
      }
   );
}

Yöntem eşzamanlılık açısından güvenli olsa daend, push_back yöntemine yapılan eşzamanlı bir çağrı tarafından end döndürülen değerin değişmesine neden olur. Yineleyicinin geçiş yaptığı öğe sayısı belirsizdir. Bu nedenle, bu program her çalıştırdığınızda farklı bir sonuç üretebilir. Öğe türü karmaşık olduğunda, push_back ve end çağrıları arasında bir yarış durumu oluşabilir. end yöntemi ayrılmış bir öğe döndürebilir, ancak tam olarak başlatılmamış olabilir.

Özel Durum Güvenliği

Bir büyüme veya atama işlemi özel durum oluşturursa, nesnenin concurrent_vector durumu geçersiz hale gelir. Geçersiz durumdaki bir concurrent_vector nesnenin davranışı, aksi belirtilmedikçe tanımlanmamıştır. Ancak yıkıcı, nesne geçersiz durumda olsa bile nesnenin ayırmış olduğu belleği her zaman serbest bırakır.

vektör öğelerinin Tveri türü aşağıdaki gereksinimleri karşılamalıdır. Aksi takdirde, sınıfın concurrent_vector davranışı tanımlanmamıştır.

• Yok edici atmamalıdır.

• Varsayılan veya kopya oluşturucu hata atarsa, yok edici anahtar sözcüğü virtual ile bildirilmemelidir ve sıfırdan başlatılan bellekle doğru şekilde çalışmalıdır.

[Üst]

concurrent_queue Sınıfı

aynı std::queue sınıfı gibi eşzamanlılık::concurrent_queue sınıfı da ön ve arka öğelerine erişmenizi sağlar. concurrent_queue sınıfı, eşzamanlı güvenli ekleme ve çıkarma işlemlerini etkinleştirir. Burada eşzamanlılık açısından güvenli, işaretçilerin veya yineleyicilerin her zaman geçerli olduğu anlamına gelir. Bu, öğe başlatmanın veya belirli bir dolaşma sırasının garantisi değildir. sınıfı concurrent_queue , eşzamanlılık açısından güvenli olmayan yineleyici desteği de sağlar.

concurrent_queue ile kuyruk arasındaki farklar

concurrent_queue sınıfı, queue sınıfına çok benzer. Aşağıdaki noktalar concurrent_queue ile queue arasındaki farkları gösterir:

• concurrent_queue nesnesi üzerinde yapılan kuyruklama ve kuyruktan çıkarma işlemleri eşzamanlı kullanım açısından güvenlidir.

• sınıfı eşzamanlılık concurrent_queue açısından güvenli olmayan yineleyici destek sağlar.

• The correct translation should read: concurrent_queue sınıfı front veya pop yöntemini sağlamaz. sınıfı, concurrent_queue try_pop yöntemini tanımlayarak bu yöntemlerin yerini alır.

• concurrent_queue sınıfı back yöntemini sağlamaz. Bu nedenle, kuyruğun sonuna erişemezsiniz.

• concurrent_queue sınıfı, size yöntemi yerine unsafe_size yöntemini sağlar. unsafe_size yöntemi eşzamanlılık açısından güvenli değildir.

Eşzamanlılık-Güvenli İşlemler

Bir concurrent_queue nesnesine eklenme veya bu nesneden çıkarılma işlemi yapan tüm yöntemler eşzamanlı güvenliğindedir. Burada eşzamanlılık açısından güvenli, işaretçilerin veya yineleyicilerin her zaman geçerli olduğu anlamına gelir. Bu, öğe başlatmanın veya belirli bir dolaşma sırasının garantisi değildir.

Aşağıdaki tabloda eşzamanlılık açısından güvenli olan yaygın concurrent_queue yöntemler ve işleçler gösterilmektedir.

empty

get_allocator

push

try_pop

empty yöntemi eşzamanlılık açısından güvenli olmasına rağmen, eşzamanlı bir işlem kuyruğun büyümesine veya küçülmesine neden olabilir ve bu, empty yöntemi döndürmeden önce gerçekleşebilir.

Aşağıdaki tabloda eşzamanlılık açısından güvenli olmayan yaygın yöntemler ve işleçler gösterilmektedir.

clear

unsafe_begin

unsafe_end

unsafe_size

Yineleyici Desteği

concurrent_queue eşzamanlılık açısından güvenli olmayan yineleyiciler sağlar. Bu yineleyicileri yalnızca hata ayıklama için kullanmanızı öneririz.

Yineleyici concurrent_queue öğeleri yalnızca ileri yönde tarar. Aşağıdaki tabloda, her yineleyicinin desteklediği işleçler gösterilmektedir.

Operatör	Açıklama
operator++	Kuyruktaki sonraki öğeye ilerler. Bu işleç hem ön artış hem de artım sonrası semantiği sağlamak için aşırı yüklenmiştir.
operator*	Geçerli öğeye bir referans alır.
operator->	Geçerli öğeye yönelik bir işaretçi alır.

[Üst]

concurrent_unordered_map Sınıfı

concurrency::concurrent_unordered_map sınıfı, std::unordered_map sınıfı gibi std::pair<const Key, Ty> türündeki öğelerin değişen uzunluklu dizisini denetleyen ilişkilendirici bir kapsayıcı sınıftır. Sırasız bir haritayı, anahtar ve değer çifti ekleyebileceğiniz veya anahtara göre bir değeri arayabileceğiniz bir sözlük olarak düşünün. Bu sınıf, paylaşılan bir kapsayıcıya eşzamanlı olarak erişmesi, kapsayıcıya eklenmesi veya güncelleştirilmesi gereken birden çok iş parçacığınız veya göreviniz olduğunda kullanışlıdır.

Aşağıdaki örnekte kullanmak concurrent_unordered_mapiçin temel yapı gösterilmektedir. Bu örnek ['a', 'i'] aralığına karakter tuşları ekler. İşlemlerin sırası belirlenmediğinden, her anahtarın son değeri de belirlenemez. Ancak, eklemeleri paralel olarak gerçekleştirmek güvenlidir.

// 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]
*/

Paralel olarak eşleme ve azaltma işlemi gerçekleştirmek için concurrent_unordered_map kullanan bir örnek için bkz: Nasıl Yapılır: Paralel Eşleme ve Azaltma İşlemleri Gerçekleştirme.

concurrent_unordered_map ile unordered_map arasındaki farklar

concurrent_unordered_map sınıfı, unordered_map sınıfına çok benzer. Aşağıdaki noktalar concurrent_unordered_map ile unordered_map arasındaki farkları gösterir:

• erase, bucket, bucket_count ve bucket_size yöntemleri sırasıyla unsafe_erase, unsafe_bucket, unsafe_bucket_count ve unsafe_bucket_size olarak adlandırılır. Adlandırma unsafe_ kuralı, bu yöntemlerin eşzamanlılık açısından güvenli olmadığını gösterir. Eşzamanlılık güvenliği hakkında daha fazla bilgi için bkz . Eşzamanlılık-Güvenli İşlemler.

• Ekleme işlemleri mevcut işaretçileri veya yineleyicileri geçersiz kılmaz veya haritada zaten var olan öğelerin sırasını değiştirmez. Ekleme ve dolaşma işlemleri eşzamanlı olarak gerçekleşebilir.

• concurrent_unordered_map yalnızca ileri yinelemeyi destekler.

• Ekleme, equal_range tarafından döndürülen yineleyicileri geçersiz kılmaz veya güncellemez. Ekleme, eşit olmayan öğeleri aralığın sonuna ekleyebilir. Başlangıç yineleyicisi eşit bir öğeye işaret eder.

Kilitlenmeyi önlemeye yardımcı olmak için hiçbir yöntem concurrent_unordered_map bellek ayırıcısını, karma işlevleri veya kullanıcı tanımlı diğer kodu çağırdığında kilit tutmaz. Ayrıca karma işlevinin her zaman eşit anahtarları aynı değere değerlendirdiğinden emin olmanız gerekir. En iyi karma işlevleri anahtarları karma kod alanı boyunca tekdüzen olarak dağıtır.

Eşzamanlılık-Güvenli İşlemler

sınıfı eşzamanlılık concurrent_unordered_map açısından güvenli ekleme ve öğe erişim işlemlerini etkinleştirir. Ekleme işlemleri mevcut işaretçileri veya yineleyicileri geçersiz kılmaz. Yineleyici erişimi ve dolaşma işlemleri de eşzamanlılık açısından güvenlidir. Burada eşzamanlılık açısından güvenli, işaretçilerin veya yineleyicilerin her zaman geçerli olduğu anlamına gelir. Bu, öğe başlatmanın veya belirli bir dolaşma sırasının garantisi değildir. Aşağıdaki tabloda eşzamanlılık açısından güvenli olan yaygın olarak kullanılan concurrent_unordered_map yöntemler ve işleçler gösterilmektedir.

at
begin
cbegin
cend

count
empty
end
equal_range

find
get_allocator
hash_function
insert

key_eq
max_size
operator[]
size

Yöntemi eşzamanlı count çalışan iş parçacıklarından güvenli bir şekilde çağrılsa da, kapsayıcıya aynı anda yeni bir değer eklenirse farklı iş parçacıkları farklı sonuçlar alabilir.

Aşağıdaki tabloda eşzamanlılık açısından güvenli olmayan yaygın olarak kullanılan yöntemler ve işleçler gösterilmektedir.

clear
load_factor

max_load_factor

operator=

rehash

Bu yöntemlere ek olarak, ile unsafe_ başlayan herhangi bir yöntem de eşzamanlılık açısından güvenli değildir.

[Üst]

concurrent_unordered_multimap Sınıfı

concurrency::concurrent_unordered_multimap sınıfı, birden fazla değerin aynı anahtarla eşlenmesine izin vermesi dışında, concurrent_unordered_map sınıfına oldukça benzemektedir. Ayrıca concurrent_unordered_map aşağıdaki şekillerde farklıdır:

• concurrent_unordered_multimap::insert yöntemi yerine std::pair<iterator, bool>bir yineleyici döndürür.

• concurrent_unordered_multimap sınıfı, ne operator[] ne de at yöntemini sağlar.

Aşağıdaki örnek, concurrent_unordered_multimap kullanımı için temel yapıyı göstermektedir. Bu örnek ['a', 'i'] aralığına karakter tuşları ekler. concurrent_unordered_multimap bir anahtarın birden çok değere sahip olmasını sağlar.

// 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]
*/

[Üst]

concurrent_unordered_set Sınıfı

concurrency::concurrent_unordered_set sınıfı, anahtar ve değer çiftleri yerine değerleri yönetmesi dışında sınıfa benzerconcurrent_unordered_map. concurrent_unordered_set sınıfı ne operator[] ne de at yöntemini sağlar.

Aşağıdaki örnekte concurrent_unordered_set kullanmak için temel yapı gösterilmektedir. Bu örnek ['a', 'i'] aralığına karakter değerleri ekler. Eklemeleri paralel olarak gerçekleştirmek güvenlidir.

// 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]
*/

[Üst]

concurrent_unordered_multiset Sınıfı

concurrency::concurrent_unordered_multiset sınıfı, yinelenen değerlere izin vermesi dışında sınıfına concurrent_unordered_set benzer. Ayrıca aşağıdaki şekillerde concurrent_unordered_set farklıdır.

• concurrent_unordered_multiset::insert yöntemi yerine std::pair<iterator, bool>bir yineleyici döndürür.

• concurrent_unordered_multiset sınıfı operator[] ya da at yöntemini sağlamaz.

Aşağıdaki örnekte kullanmak concurrent_unordered_multisetiçin temel yapı gösterilmektedir. Bu örnek ['a', 'i'] aralığına karakter değerleri ekler. concurrent_unordered_multiset bir değerin birden çok kez gerçekleşmesini sağlar.

// 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]
*/

[Üst]

combinable Sınıfı

concurrency::combinable sınıfı, ayrıntılı hesaplamalar yapmanıza ve ardından bu hesaplamaları nihai bir sonuçla birleştirmenize olanak tanıyan yeniden kullanılabilir, iş parçacığı yerel depolama alanı sağlar. Nesneyi combinable azaltma değişkeni olarak düşünebilirsiniz.

sınıfı combinable , birkaç iş parçacığı veya görev arasında paylaşılan bir kaynağınız olduğunda kullanışlıdır. sınıfı, combinable paylaşılan kaynaklara kilitsiz bir şekilde erişim sağlayarak paylaşılan durumu ortadan kaldırmanıza yardımcı olur. Bu nedenle, bu sınıf birden çok iş parçacığından paylaşılan verilere erişimi eşitlemek için bir eşitleme mekanizması (örneğin, bir mutex) kullanmaya bir alternatif sağlar.

Yöntemler ve Özellikler

Aşağıdaki tabloda sınıfın önemli yöntemlerinden bazıları gösterilmektedir combinable . Tüm combinable sınıf yöntemleri hakkında daha fazla bilgi için bkz . Birleştirilebilir Sınıf.

Metot	Açıklama
Yerel	Geçerli iş parçacığı bağlamıyla ilişkili yerel değişkene başvuru alır.
berrak	combinable nesnesinden tüm iş parçacığı yerel değişkenlerini kaldırır.
birleştirmek combine_each	Sağlanan birleştirme işlevini kullanarak tüm iş parçacığı yerel hesaplamaları kümesinden nihai bir değer oluşturur.

combinable sınıfı, son birleştirilmiş sonuç üzerinde parametreleştirilmiş bir şablon sınıfıdır. Varsayılan oluşturucuyu çağırırsanız, T şablon parametre türünün varsayılan bir oluşturucu ve bir kopya oluşturucuya sahip olması gerekir. T Şablon parametre türü varsayılan bir oluşturucuya sahip değilse, oluşturucunun parametresi olarak bir başlatma işlevi alan aşırı yüklenmiş sürümünü çağırın.

Birleştirme veya combine_each yöntemlerini çağırdıktan sonra nesnede combinableek veriler depolayabilirsiniz. Ayrıca combine ve combine_each yöntemlerini birden çok kez çağırabilirsiniz. Nesnedeki combinable hiçbir yerel değer değişmezse ve combinecombine_each yöntemleri her çağrıldıklarında aynı sonucu verir.

Örnekler

sınıfını combinable kullanma hakkında örnekler için aşağıdaki konulara bakın:

• Nasıl yapılır: Performansı arttırmak için combinable Kullanma

• Nasıl yapılır: Kümeleri Birleştirmek için combinable Kullanma

[Üst]

İlgili Konular

Nasıl yapılır: Etkinliği Arttırmak için Paralel Kapsayıcılar Kullanma
Verileri paralel olarak verimli bir şekilde depolamak ve verilere erişmek için paralel kapsayıcıların nasıl kullanılacağını gösterir.

Nasıl yapılır: Performansı arttırmak için combinable Kullanma
Paylaşılan durumu ortadan kaldırmak ve böylece performansı geliştirmek için sınıfın combinable nasıl kullanılacağını gösterir.

Nasıl yapılır: Kümeleri Birleştirmek için combinable Kullanma
Yerel iş parçacığı veri kümelerini birleştirmek için bir combine işlevinin nasıl kullanılacağını gösterir.

Paralel Desen Kitaplığı (PPL)
Eşzamanlı uygulamalar geliştirmek için ölçeklenebilirliği ve kullanım kolaylığını destekleyen kesinlik temelli bir programlama modeli sağlayan PPL'yi açıklar.

Referans

concurrent_vector Sınıfı

concurrent_queue Sınıfı

concurrent_unordered_map Sınıfı

concurrent_unordered_multimap Sınıfı

concurrent_unordered_set Sınıfı

concurrent_unordered_multiset Sınıfı

Birleştirilebilir Sınıf