Paralel kapsayıcıları ve nesneleri

Paralel desen kitaplığı (ppl) birkaç kap ve öğelerini iş parçacığı güvenli erişim sağlayan nesneleri içerir.

A eşzamanlı kapsayıcı en önemli işlemleri eşzamanlılık güvenli erişim sağlar. Bu kapsayıcı işlevi, standart şablon kitaplığı (stl) tarafından sağlanan benzer. Örneğin, concurrency::concurrent_vector sınıf benzer std::vector , dışında sınıfı concurrent_vector sınıfı paralel öðeler append olanak sağlar. Okuma ve yazma erişimi aynı kapsayıcı gerektirir paralel kodu varsa, eşzamanlı kapları kullanın.

A eşzamanlı nesne aynı anda bileşenler arasında paylaşılır. Paralel eşzamanlı bir nesnenin durumunu hesaplar işlem seri olarak aynı durumu hesaplar başka bir işlem aynı sonucu üretir. Concurrency::combinable eşzamanlı nesne türünün bir örneği bir sınıftır. combinable Paralel olarak hesaplamaları gerçekleştirmek ve sonra bu hesaplamaları Nihai sonuç halinde birleştirmek sınıfı olanak sağlar. Aksi halde, bir mutex eşitleme mekanizması paylaşılan bir değişken veya kaynak erişimi eşitlemek için kullanacağınız eşzamanlı nesneleri kullanın.

Bölümler

Bu konuda aşağıdaki paralel kapsayıcıları ve nesneleri ayrıntılı açıklanmıştır.

Eşzamanlı kapsayıcı:

• concurrent_vector sınıfı

  • Concurrent_vector arasındaki farklar ve vektör

  • Eşzamanlılık güvenli işlemleri

  • Özel güvenlik

• concurrent_queue sınıfı

  • Concurrent_queue arasındaki farklar ve sıra

  • Eşzamanlılık güvenli işlemleri

  • Yineleyici desteği

• concurrent_unordered_map sınıfı

  • Farklılıklar arasında concurrent_unordered_map ve unordered_map

  • Eşzamanlılık güvenli işlemleri

• concurrent_unordered_multimap sınıfı

• concurrent_unordered_set sınıfı

• concurrent_unordered_multiset sınıfı

Eşzamanlı nesneleri:

• combinable sınıfı

  • Yöntemleri ve özellikleri

  • Örnekler

concurrent_vector sınıfı

Concurrency::concurrent_vector sınıfı olduğu gibi bir sıra container sınıfının std::vector sınıfı, rastgele öğelerini erişmenize olanak sağlar. concurrent_vector Sınıfı sağlar eşzamanlılık güvenli ekleme ve öğe erişim işlemleri. Append geçersiz işlem değil kılmak varolan işaretçileri veya Yineleyicilerde. Yineleyici erişim ve çapraz geçiş işlemleri de eşzamanlılık güvenlidir.

Concurrent_vector arasındaki farklar ve vektör

concurrent_vector Class benzeyen vector sınıfı. Append öğesinin erişimi ve Yineleyici erişim işlemlerini karmaşıklığını bir concurrent_vector nesne aynı olan bir vector nesnesi. Aşağıdaki noktaları yeri göstermek concurrent_vector farklı vector:

• Ekleme, öğe erişimi, Yineleyici erişim ve Yineleyici çapraz geçiş işlemleri üzerinde bir concurrent_vector nesne eşzamanlılık güvenli.

• Öğeleri yalnızca sonuna eklemek bir concurrent_vector nesnesi. concurrent_vector Class sağlamaz insert yöntemi.

• A concurrent_vector nesnesini kullanmak değil anlamını taşır zaman, eklemek için.

• concurrent_vector Class sağlamaz erase veya pop_back yöntemleri. Olduğu gibi vector, kullanma temizleyin gelen tüm öğeleri kaldırmak için yöntem bir concurrent_vector nesnesi.

• concurrent_vector Sınıfı değil saklamak öğelerini bitişik bellek. Bu nedenle, kullanamazsınız concurrent_vector bir dizi kullanabilirsiniz şekilde sınıf. Örneğin, adlı bir değişken için v türü concurrent_vector, deyim &v[0]+2 tanımsız davranış üretir.

• concurrent_vector Sınıfını tanımlar grow_by ve grow_to_at_least yöntemleri. Bu yöntemler benzer yeniden boyutlandırma yöntemi, eşzamanlılık güvenli oldukları olmasıdır.

• A concurrent_vector nesnesi değil yükleyebileceğiniz öğeleri eklemek için Ekle'yi veya yeniden boyutlandırın. Bu, varolan işaretçiler ve Yineleyicilerde eşzamanlı işlemler sırasında geçerli kalmasını sağlar.

• Çalışma zamanı, özelleştirilmiş bir sürümünü tanımlamaz concurrent_vector türü bool.

Eşzamanlılık güvenli işlemleri

Eklemek veya boyutunu bütün yöntemler bir concurrent_vector nesne veya öğeye erişim bir concurrent_vector nesne, eşzamanlılık güvenli. Bu kuralın istisnası resize yöntemi.

Aşağıdaki tabloda, yaygın gösterir concurrent_vector yöntemleri ve eşzamanlılık güvenli operators.

AT	Son	operator]
başlamak	Ön	push_back
geri	grow_by	rbegin
Kapasite	grow_to_at_least	rend
boş	max_size	boyutu

Örneğin, çalışma zamanı stl ile uyumluluk için sağladığı işlemleri reserve, eşzamanlılık güvenli değildir. Genel yöntemleri ve eşzamanlılık güvenli olmayan işleçler aşağıdaki tabloda gösterilmiştir.

atama	rezerve et
Temizle	yeniden boyutlandırma
operator =	shrink_to_fit

Varolan öğelerin değerini değiştirme işlemleri eşzamanlılık güvenli değildir. Eşitleme nesnesi gibi kullanmak bir reader_writer_lock nesnesine eşitleyin eşzamanlı okuma ve yazma işlemleri için aynı veri öğesi. Eşitleme nesneleri hakkında daha fazla bilgi için bkz: Eşitleme veri yapıları.

Kullanan varolan kodu dönüştürürken vector kullanmak için concurrent_vector, eşzamanlı operasyonlar davranışını değiştirmek için uygulamanızın neden olabilir. Örneğin, iki görevin aynı anda gerçekleştirir aşağıdaki programı ele alalım bir concurrent_vector nesnesi. İlk görev için ek öğeler ekler bir concurrent_vector nesnesi. İkinci görev tüm öğeler, aynı nesne 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;
      }
   );
}

Rağmen end eşzamanlılık-güvenli yöntemdir eşzamanlı çağrısı push_back yöntemi tarafından döndürülen değeri neden end değiştirmek için. Yineleyici erişir öğelerin sayısı belirsiz. Bu nedenle, bu programı çalıştırmak, her seferinde farklı bir sonuç üretebilir.

Özel güvenlik

Büyüme veya atama işleminin durumunu bir istisna atar, concurrent_vector nesnesi geçersiz olur. Davranışını bir concurrent_vector geçersiz bir durumda nesne aksi belirtilmedikçe tanımlanmamış. Ancak, nesne geçersiz bir durumda olsa bile, yıkıcı her zaman nesne ayıran belleği boşaltır.

Veri türü, vector öğeleri _Ty, aşağıdaki gereksinimleri karşılaması gerekir. Aksi takdirde davranışını concurrent_vector Sınıf tanımlanmamış.

• Yıkıcı oluşturması gerekir değil.

• Varsayılan veya kopya yapıcı oluşturursa, yıkıcı kullanarak bildirilmelidir virtual anahtar sözcüğünü ve çalışmalıdır doğru bellek sıfır başlatıldı.

Top

concurrent_queue sınıfı

Concurrency::concurrent_queue , tıpkı sınıf std::queue sınıfı, erişim, ön ve arka öğeleri sağlar. concurrent_queue Class eşzamanlılık güvenli enqueue etkinleştirir ve sıradan çıkarma işlemleri. concurrent_queue Sınıfı, eşzamanlılık-güvenli deðildir Yineleyici desteği de sağlar.

Concurrent_queue arasındaki farklar ve sıra

concurrent_queue Class benzeyen queue sınıfı. Aşağıdaki noktaları yeri göstermek concurrent_queue farklı queue:

• Enqueue ve işlemleri sıradan çıkarma bir concurrent_queue nesne eşzamanlılık güvenli.

• concurrent_queue Sınıfı, eşzamanlılık-güvenli deðildir Yineleyici destek sağlar.

• concurrent_queue Class sağlamaz front veya pop yöntemleri. concurrent_queue Sınıf tanımlanarak bu yöntemlerin yerini try_pop yöntemi.

• concurrent_queue Class sağlamaz back yöntemi. Bu nedenle, sıranın sonuna başvuru yapamazsınız.

• concurrent_queue SAX unsafe_size yöntemi yerine size yöntemi. unsafe_size Yöntemi eşzamanlılık güvenli değil.

Eşzamanlılık güvenli işlemleri

Tüm yöntemleri o enqueue veya gelen sıradan çıkarma bir concurrent_queue nesne eşzamanlılık güvenli.

Aşağıdaki tabloda, yaygın gösterir concurrent_queue yöntemleri ve eşzamanlılık güvenli operators.

boş	İtme
get_allocator	try_pop

Ancak empty eşzamanlılık güvenli bir yöntemdir, eşzamanlı işlem sıraya ulaşması veya önce küçültmek neden empty yöntemini döndürür.

Genel yöntemleri ve eşzamanlılık güvenli olmayan işleçler aşağıdaki tabloda gösterilmiştir.

Temizle	unsafe_end
unsafe_begin	unsafe_size

Yineleyici desteği

concurrent_queue Eşzamanlılık güvenli olmayan Yineleyicilerde sağlar. Yalnızca hata ayıklama için bu Yineleyicilerde kullanmanızı öneririz.

A concurrent_queue öğeleri yalnızca ileri yönde Yineleyici erişir. Aşağıdaki tabloda, operatörler her Yineleyici desteklediğini gösterir.

İşleç	Description
operator ++	Sıradaki bir sonraki öğeye geliştirmeleri. Bu işleç, pre-increment ve post-increment semantiği sağlamak için aşırı.
operator *	Geçerli madde için bir başvuru alır.
Operatör - >	Geçerli madde için bir işaretçi alır.

Top

concurrent_unordered_map sınıfı

Concurrency::concurrent_unordered_map sınıfı olduğu gibi ilişkilendirilebilir kapsayıcı sınıfı std::unordered_map sınıfı, bu türdeki öğeleri değişen uzunlukta sırasını kontrol std::pair < const anahtar, Ty >. Sıralanmamış bir haritasını bir anahtar ve değer çifti eklemek veya anahtarının değerini bakmak bir sözlük olarak düşünün. Bu sınıfın birden çok iş parçacığı veya görevleri aynı anda paylaşılan bir konteyner erişmek, içine eklemek veya güncelleştirmek için gerekli olduğunda yararlıdır.

Temel yapısı kullanmak için aşağıdaki örnekte gösterildiği concurrent_unordered_map. Bu örnek aralığı ['a', ' i'] karakter tuşlarını ekler. İşlem sırası belirlenmemiş olduğundan, her anahtarın son değeri de yapılmadığı. Ancak, paralel olarak eklemeler yapmak 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]
*/

Kullanan bir örnek için concurrent_unordered_map paralel işlem azaltmak ve harita gerçekleştirmek için bkz: Nasıl yapılır: harita gerçekleştirmek ve paralel işlemleri azaltma.

Farklılıklar arasında concurrent_unordered_map ve unordered_map

concurrent_unordered_map Class benzeyen unordered_map sınıfı. Aşağıdaki noktaları yeri göstermek concurrent_unordered_map farklı unordered_map:

• The erase, bucket, bucket_count, and bucket_size methods are named unsafe_erase, unsafe_bucket, unsafe_bucket_count, and unsafe_bucket_size, respectively. unsafe_ Adlandırma kuralını gösterir bu yöntemleri eşzamanlılık güvenli değildir. Eşzamanlılık güvenliği hakkında daha fazla bilgi için bkz: Eşzamanlılık güvenli işlemler.

• Geçersiz ekleme işlemlerini varolan işaretçileri veya Yineleyicilerde kılmak değil, ne de haritada bulunmayan öğelerin sırasını değiştirme. Takın ve çapraz geçiş işlemlerini aynı anda oluşabilir.

• concurrent_unordered_mapyalnızca yineleme destekler iletin.

• Ekleme geçersiz kılmak veya değil tarafından döndürülen Yineleyicilerde güncelleştirmek equal_range. Ekleme, aralığın sonuna eşit olmayan öğeler ekleyebilir. Begin Yineleyici eşit bir öğeye işaret eder.

Kilitlenme, hiçbir yöntemi önlemeye yardımcı olmak için concurrent_unordered_map bellek ayırıcısı, karma işlevler veya diğer kullanıcı tanımlı kod çağırdığında kilit tutan. Ayrıca, karma işlevi her zaman aynı değere eşit anahtarları değerlendirir emin olmalısınız. En iyi karma işlevler tuşları hep karma kodu alanı arasında dağıtın.

Eşzamanlılık güvenli işlemleri

concurrent_unordered_map Class eşzamanlılık güvenli ekleme ve öğe erişim işlemlerini etkinleştirir. Geçersiz ekleme işlemlerini varolan işaretçileri veya Yineleyicilerde kılmak değil. Yineleyici erişim ve çapraz geçiş işlemleri de eşzamanlılık güvenlidir. Aşağıdaki tabloda, yaygın olarak kullanılan gösterir concurrent_unordered_map yöntemleri ve eşzamanlılık güvenli operators.

AT	count	find	key_eq
begin	empty	get_allocator	max_size
cbegin	end	hash_function	operator]
cend	equal_range	Ekle	size

Ancak count yöntemi adlı güvenle iş parçacıklarını eşzamanlı olarak yürütülen, yeni bir değer kapsayıcıya eşzamanlı olarak eklenirse, farklı iş parçacıklarının farklı sonuçlar alabilir.

Sık kullanılan yöntemler ve eşzamanlılık güvenli olmayan işleçler aşağıdaki tabloda gösterilmiştir.

clear	max_load_factor	rehash
load_factor	operator =	takas

Bu yöntemlere ek olarak, herhangi bir yöntem, ile başlayıp unsafe_ de eşzamanlılık-güvenli deðildir.

Top

concurrent_unordered_multimap sınıfı

Concurrency::concurrent_unordered_multimap class benzeyen concurrent_unordered_map dışında aynı anahtar eşlemek birden çok değer verir, sınıf. Bunu da farklı concurrent_unordered_map şu şekilde:

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

• concurrent_unordered_multimap Class sağlamaz operator[] ne at yöntemi.

Temel yapısı kullanmak için aşağıdaki örnekte gösterildiği concurrent_unordered_multimap. Bu örnek aralığı ['a', ' i'] karakter tuşlarını ekler. concurrent_unordered_multimapbirden çok değer bir anahtar 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]
*/

Top

concurrent_unordered_set sınıfı

Concurrency::concurrent_unordered_set class benzeyen concurrent_unordered_map dışında anahtar ve değer çiftleri yerine değerlerini yönetir, sınıf. concurrent_unordered_set Class sağlamaz operator[] ne at yöntemi.

Temel yapısı kullanmak için aşağıdaki örnekte gösterildiği concurrent_unordered_set. Bu örnek aralığı ['a', ' i'] karakter değerlerini ekler. Paralel olarak eklemeler yapmak 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]
*/

Top

concurrent_unordered_multiset sınıfı

Concurrency::concurrent_unordered_multiset class benzeyen concurrent_unordered_set dışında yinelenen değerleri sağlayan sınıf. Bunu da farklı concurrent_unordered_set şu şekilde:

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

• concurrent_unordered_multiset Class sağlamaz operator[] ne at yöntemi.

Temel yapısı kullanmak için aşağıdaki örnekte gösterildiği concurrent_unordered_multiset. Bu örnek aralığı ['a', ' i'] karakter değerlerini ekler. concurrent_unordered_multisetbirden çok kez gerçekleşmesi bir değer 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]
*/

Top

combinable sınıfı

Concurrency::combinable sınıfını uygulamanıza hesaplamaları gerçekleştirmek ve sonra bu hesaplamaların sonucunu birleştirme sağlar yeniden kullanılabilir, iş parçacığı yerel depolama sağlar. Düşünebilirsiniz bir combinable nesne azaltma değişkeni olarak.

combinable Sınıfı, birkaç iş parçacığı veya görevleri arasında paylaşılan bir kaynağa sahip olduğunuzda yararlıdır. combinable Sınıfı kilidi serbest bir şekilde paylaşılan kaynaklara erişim sağlayarak paylaşılan durum ortadan kaldırmak yardımcı olur. Bu nedenle, bu sınıfın birden çok iş parçacığı için paylaşılan veri erişimi eşitlemek için bir mutex eşitleme mekanizması kullanılarak alternatif sağlar.

Yöntemleri ve özellikleri

Aşağıdaki tabloda bazı önemli yöntemlerinden birini gösterir combinable sınıfı. Tüm hakkında daha fazla bilgi için combinable sınıf yöntemleri için bkz: combinable sınıfı.

Method	Description
yerel	Geçerli iş parçacığı içeriği ile ilişkili yerel değişkenin başvurusu alır.
Temizle	Gelen tüm iş parçacığı yerel değişkenleri kaldırır combinable nesnesi.
Birleştir combine_each	Tüm iş parçacığı yerel hesaplamaları kümesinden son değeri üretmek için sağlanan Birleştir fonksiyonunu kullanır.

combinable Birleştirilen sonuç üzerinde parametreli bir şablon sınıfı bir sınıftır. Varsayılan kurucuyu çağırdığınızda, _Ty bir varsayılan kurucu ve kopyalama kurucusunu şablona parametre türü olması gerekir. _Ty Şablon parametre türü varsayılan bir oluşturucuya sahip değil, aşırı yüklü sürümünü alır, parametre olarak bir başlatma işlevi oluşturucu çağrısı.

Ek veri depolayabilir bir combinable , çağrısından sonra nesne bir araya veya combine_each yöntemleri. Ayrıca çağrı combine ve combine_each yöntem birden çok kez. Yerel değeri yok, bir combinable nesne değişiklikleri, combine ve combine_each yöntemleri olarak adlandırılırlar her zaman aynı sonucu üretir.

Örnekler

Yardımın nasıl kullanılacağını gösteren örnekler için combinable sınıfı, aşağıdaki konulara bakın:

• Nasıl yapılır: performansı artırmak için combinable kullan

• Nasıl yapılır: Birleştir kümeleri için combinable kullanın

Top

İlgili Konular

• Nasıl yapılır: verimliliği artırmak için paralel kapları kullanın
  Paralel kapsayıcıları verimli saklamak ve paralel veri erişimi için nasıl kullanılacağını gösterir.

• Nasıl yapılır: performansı artırmak için combinable kullan
  Nasıl kullanılacağını gösteren combinable paylaşılan durumu ortadan kaldırmak için sınıf ve dolayısıyla performansı artırmak.

• Nasıl yapılır: Birleştir kümeleri için combinable kullanın
  Nasıl kullanılacağını gösteren bir combine iş parçacığı yerel veri kümelerini birleştirmek için işlevi.

• Paralel Desenler kitaplığının (ppl)
  Ölçeklenebilirlik ve kolaylığı eş zamanlı uygulamalar geliştirmek için kullanım yükseltir zararlara bir programlama modeli sağlar ppl açıklar.

Reference

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ı