C++ Boost Lockfree超詳細講解使用方法

Boost.Lockfree

一、說明

Boost.Lockfree 提供執行緒安全和無鎖容器。可以從多個執行緒存取此庫中的容器，而無需同步存取。

在 1.56.0 版本中，Boost.Lockfree 只提供了兩個容器：boost::lockfree::queue 型別的佇列和 boost::lockfree::stack 型別的棧。對於佇列，可以使用第二個實現：boost::lockfree::spsc_queue。此類針對只有一個執行緒寫入佇列和只有一個執行緒從佇列讀取的用例進行了優化。類名中的縮寫 spsc 代表單一生產者/單一消費者。

二、範例和程式碼

範例 46.1。使用 boost::lockfree::spsc_queue

#include <boost/lockfree/spsc_queue.hpp>
#include <thread>
#include <iostream>
boost::lockfree::spsc_queue<int> q{100};
int sum = 0;
void produce()
{
  for (int i = 1; i <= 100; ++i)
    q.push(i);
}
void consume()
{
  int i;
  while (q.pop(i))
    sum += i;
}
int main()
{
  std::thread t1{produce};
  std::thread t2{consume};
  t1.join();
  t2.join();
  consume();
  std::cout << sum << 'n';
}

Example46.1

範例 46.1 使用容器 boost::lockfree::spsc_queue。第一個執行函數 produce() 的執行緒將數位 1 到 100 新增到容器中。第二個執行緒執行 consume()，從容器中讀取數位並將它們相加。因為容器 boost::lockfree::spsc_queue 明確支援來自兩個執行緒的並行存取，所以不需要同步執行緒。

請注意，函數 consume() 會線上程終止後被第二次呼叫。這需要計算所有 100 個數位的總數，即 5050。因為 consume() 在迴圈中存取佇列，它讀取數位的速度可能比 produce() 插入數位的速度快。如果佇列為空，pop() 返回 false。因此，執行 consume() 的執行緒可能會終止，因為另一個執行緒中的 produce() 無法足夠快地填充佇列。如果執行 produce() 的執行緒終止，那麼很明顯所有數位都已新增到佇列中。第二次呼叫 consume() 確保將可能尚未讀取的數位新增到 sum 中。

佇列的大小被傳遞給建構函式。因為 boost::lockfree::spsc_queue 是用迴圈緩衝區實現的，所以範例 46.1 中的佇列容量為 100 個元素。如果由於佇列已滿而無法新增值，則 push() 返回 false。該範例不檢查 push() 的返回值，因為恰好有 100 個數位被新增到佇列中。因此，100 個元素就足夠了。

範例 46.2。 boost::lockfree::spsc_queue 和 boost::lockfree::capacity

#include <boost/lockfree/spsc_queue.hpp>
#include <boost/lockfree/policies.hpp>
#include <thread>
#include <iostream>
using namespace boost::lockfree;
spsc_queue<int, capacity<100>> q;
int sum = 0;
void produce()
{
  for (int i = 1; i <= 100; ++i)
    q.push(i);
}
void consume()
{
  while (q.consume_one([](int i){ sum += i; }))
    ;
}
int main()
{
  std::thread t1{produce};
  std::thread t2{consume};
  t1.join();
  t2.join();
  q.consume_all([](int i){ sum += i; });
  std::cout << sum << 'n';
}

Example46.2

範例 46.2 與前面的範例類似，但這次迴圈緩衝區的大小是在編譯時設定的。這是通過模板 boost::lockfree::capacity 完成的，它需要容量作為模板引數。 q 是用預設建構函式範例化的——容量不能在執行時設定。

函數 consume() 已更改為使用 consume_one() 而不是 pop() 來讀取數位。 lambda 函數作為引數傳遞給 consume_one()。 consume_one() 就像 pop() 一樣讀取一個數位，但該數位不是通過對呼叫者的參照返回的。它作為唯一引數傳遞給 lambda 函數。

當執行緒終止時，main() 呼叫成員函數 consume_all()，而不是 consume()。 consume_all() 的工作方式與 consume_one() 類似，但要確保佇列在呼叫後為空。只要佇列中有元素，consume_all() 就會呼叫 lambda 函數。

範例 46.2 再次將 5050 寫入標準輸出。

範例 46.3。具有可變容器大小的 boost::lockfree::queue

#include <boost/lockfree/queue.hpp>
#include <thread>
#include <atomic>
#include <iostream>
boost::lockfree::queue<int> q{100};
std::atomic<int> sum{0};
void produce()
{
  for (int i = 1; i <= 10000; ++i)
    q.push(i);
}
void consume()
{
  int i;
  while (q.pop(i))
    sum += i;
}
int main()
{
  std::thread t1{produce};
  std::thread t2{consume};
  std::thread t3{consume};
  t1.join();
  t2.join();
  t3.join();
  consume();
  std::cout << sum << 'n';
}

Example46.3

範例 46.3 在兩個執行緒中執行 consume()。因為有多個執行緒從佇列中讀取，所以不得使用類 boost::lockfree::spsc_queue。此範例改為使用 boost::lockfree::queue。

多虧了 std::atomic，對變數 sum 的存取現在也是執行緒安全的。

佇列的大小設定為 100——這是傳遞給建構函式的引數。但是，這只是初始大小。預設情況下，boost::lockfree::queue 不使用迴圈緩衝區實現。如果新增到佇列中的專案多於設定的容量，則會自動增加。如果初始大小不夠，boost::lockfree::queue 會動態分配額外的記憶體。

這意味著 boost::lockfree::queue 不一定是無鎖的。 boost::lockfree::queue 預設使用的分配器是 boost::lockfree::allocator，它基於 std::allocator。因此，此分配器確定 boost::lockfree::queue 是否是無約束的無鎖。

#include <boost/lockfree/queue.hpp>
#include <thread>
#include <atomic>
#include <iostream>
using namespace boost::lockfree;
queue<int, fixed_sized<true>> q{10000};
std::atomic<int> sum{0};
void produce()
{
  for (int i = 1; i <= 10000; ++i)
    q.push(i);
}
void consume()
{
  int i;
  while (q.pop(i))
    sum += i;
}
int main()
{
  std::thread t1{produce};
  std::thread t2{consume};
  std::thread t3{consume};
  t1.join();
  t2.join();
  t3.join();
  consume();
  std::cout << sum << 'n';
}

Example46.4

範例 46.3 在兩個執行緒中執行 consume()。因為有多個執行緒從佇列中讀取，所以不得使用類 boost::lockfree::spsc_queue。此範例改為使用 boost::lockfree::queue。

多虧了 std::atomic，對變數 sum 的存取現在也是執行緒安全的。

佇列的大小設定為 100——這是傳遞給建構函式的引數。但是，這只是初始大小。預設情況下，boost::lockfree::queue 不使用迴圈緩衝區實現。如果新增到佇列中的專案多於設定的容量，則會自動增加。如果初始大小不夠，boost::lockfree::queue 會動態分配額外的記憶體。

這意味著 boost::lockfree::queue 不一定是無鎖的。 boost::lockfree::queue 預設使用的分配器是 boost::lockfree::allocator，它基於 std::allocator。因此，此分配器確定 boost::lockfree::queue 是否是無約束的無鎖。

範例 46.4。具有恆定容器大小的 boost::lockfree::queue

到此這篇關於C++ Boost Lockfree超詳細講解使用方法的文章就介紹到這了,更多相關C++ Boost Lockfree內容請搜尋it145.com以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援it145.com！