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şlatma 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 concurrent_vector benzer, ancak sınıfı öğeleri paralel olarak eklemenize izin verir. 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. Paylaşılan değişkene veya kaynağa erişimi eşitlemek için eşitleme mekanizması (örneğin, bir mutex) kullandığınızda eşzamanlı nesneleri 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:

• combinable 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. sınıfı eşzamanlılık concurrent_vector 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şlatma veya belirli bir dolaşma sırasının garantisi değildir.

concurrent_vector ve vektör arasındaki farklar

sınıfı, concurrent_vector sınıfına vector ç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, ile vectorarasındaki farkları gösterirconcurrent_vector:

• 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ı yöntemini sağlamazinsert.

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

• concurrent_vector sınıfı veya pop_back yöntemlerini sağlamazerase. gibivector, bir concurrent_vector nesneden 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 concurrent_vectoradlı v bir değişken için ifade &v[0]+2 tanımsız davranış üretir.

• sınıfı, concurrent_vector grow_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ı türü booliçin özel bir sürümünü concurrent_vector tanımlamaz.

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

Bir nesnenin sonuna eklenen veya nesnenin boyutunu artıran ya da nesnedeki concurrent_vector concurrent_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şlatma 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ı.

kullanan vector mevcut kodu kullanarak concurrent_vectordö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ü önemsiz olmadığında ve çağrıları arasında push_back end bir yarış durumu olması mümkündür. 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 oluşturursa, yok edici anahtar sözcüğü kullanılarak virtual bildirilmemeli ve sıfır 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. sınıfı eşzamanlılık concurrent_queue açısından güvenli sıralama ve dequeue 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şlatma 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

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

• Nesnedeki concurrent_queue sıralama ve sıralamayı kaldırma işlemleri eşzamanlılık açısından güvenlidir.

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

• concurrent_queue sınıfı veya pop yöntemlerini sağlamazfront. sınıfı, concurrent_queue try_pop yöntemini tanımlayarak bu yöntemlerin yerini alır.

• concurrent_queue sınıfı yöntemini sağlamazback. Bu nedenle, kuyruğun sonuna başvuramazsınız.

• sınıfı, concurrent_queue yöntemi yerine size 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 nesneye gelen veya nesneden gelen 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şlatma 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

Yöntem eşzamanlılık açısından güvenli olsa empty da, eşzamanlı bir işlem yöntemi döndürmeden önce empty kuyruğun büyümesine veya küçülmesine neden olabilir.

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

eşzamanlılık concurrent_queue 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 çapraz geçişler. Aşağıdaki tabloda, her yineleyicinin desteklediği işleçler gösterilmektedir.

Operator	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 başvuru 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::p air<const Key, Ty> türündeki öğelerin değişen uzunluklu dizisini denetleen ilişkilendirici bir kapsayıcı sınıfıdır. Sıralanmamış bir eşlemeyi anahtar ve değer çifti ekleyebileceğiniz veya anahtara göre değer 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]
*/

Eşleme ve azaltma işlemini paralel olarak gerçekleştirmek için kullanan concurrent_unordered_map 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

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

• , , ve yöntemleri sırasıyla , unsafe_bucket, unsafe_bucket_countve unsafe_bucket_sizeolarak adlandırılırunsafe_erase.bucket_size bucket_countbucketerase 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, tarafından equal_rangedöndürülen yineleyicileri geçersiz kılmaz veya güncelleştirmez. 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şlatma 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ı, aynı anahtarla eşlenen birden çok değere izin vermesi dışında sınıfına benzerconcurrent_unordered_map. Ayrıca aşağıdaki yollardan concurrent_unordered_map farklıdır:

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

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

Aşağıdaki örnekte kullanmak concurrent_unordered_multimapiçin temel yapı gösterilmektedir. 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. sınıfı concurrent_unordered_set ne yöntemini sağlamaz operator[] at .

Aşağıdaki örnekte kullanmak concurrent_unordered_setiç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 yollardan concurrent_unordered_set farklıdır:

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

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

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
local	Geçerli iş parçacığı bağlamıyla ilişkili yerel değişkene başvuru alır.
berrak	Nesneden combinable tüm iş parçacığı yerel değişkenlerini kaldırır.
birleşmek combine_each	Sağlanan combine işlevini kullanarak tüm iş parçacığı yerel hesaplamaları kümesinden son 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 combinable ek veriler depolayabilirsiniz. ve combine_each yöntemlerini birden çok kez de çağırabilirsinizcombine. Nesnedeki combinable hiçbir yerel değer değişmezse ve combine combine_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'a

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
İş parçacığı yerel veri kümelerini birleştirmek için bir combine işlevin 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.

Başvuru

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ı

combinable Sınıfı