Tôi đã tìm kiếm trên Google một chút cho một hàng đợi không có khóa trong C ++. Tôi đã tìm thấy một số mã và một số thử nghiệm - nhưng không có gì mà tôi có thể biên dịch. Một hàm băm không có khóa cũng sẽ được hoan nghênh.
TÓM TẮT: Cho đến nay tôi không có câu trả lời tích cực nào. Không có thư viện "sẵn sàng sản xuất" và đáng ngạc nhiên là không có thư viện hiện có nào tuân thủ API của vùng chứa STL.
Câu trả lời:
Kể từ 1.53, boost cung cấp một tập hợp các cấu trúc dữ liệu miễn phí có khóa , bao gồm hàng đợi, ngăn xếp và hàng đợi đơn sản xuất / người tiêu dùng đơn (tức là bộ đệm vòng).
Điểm khởi đầu sẽ là một trong các bài báo DDJ của Herb Sutter cho một nhà sản xuất và người tiêu dùng hoặc nhiều bài báo . Mã mà anh ta đưa ra (trong dòng bắt đầu từ trang thứ hai của mỗi bài viết) sử dụng kiểu mẫu C ++ 0x kiểu nguyên tử <T>; mà bạn có thể bắt chước bằng cách sử dụng thư viện liên quy trình Boost.
Mã tăng cường được chôn sâu trong thư viện liên quy trình, nhưng sau khi đọc qua tệp tiêu đề thích hợp (atom.hpp), các triển khai cho các hoạt động so sánh và hoán đổi cần thiết trên các hệ thống mà tôi đã quen thuộc.
Tôi đã viết một hàng đợi không có khóa . Nó có các Tính năng ™:
Nó có sẵn trên GitHub theo giấy phép BSD đơn giản hóa (vui lòng tách nó!).
Lưu ý:
Folly của Facebook dường như đã khóa các cấu trúc dữ liệu miễn phí dựa trên C ++ 11 <atomic>:
ProducerConsumerQueue với tài liệu và mã ví dụ ở đây .
AtomicHashMap với tài liệu và mã ví dụ tại đây
Tôi dám nói rằng chúng hiện đang được sử dụng trong sản xuất, vì vậy tôi đoán chúng có thể được sử dụng một cách an toàn trong các dự án khác.
Chúc mừng!
Sau khi đã kiểm tra hầu hết các câu trả lời đã cho, tôi chỉ có thể nói:
Câu trả lời là KHÔNG .
Không có thứ quyền nào có thể được sử dụng ngay lập tức.
boost.lockfree là một nỗ lực để tạo ra các triển khai c ++ của ngăn xếp lockfree và các lớp XVo.
Điều gần nhất mà tôi biết là Windows Interlocked Singly Linked Lists . Tất nhiên, nó chỉ dành cho Windows.
Nếu bạn có Hàng đợi nhiều nhà sản xuất / một người tiêu dùng / FIFO, bạn có thể dễ dàng tạo một LockFree bằng cách sử dụng SLIST hoặc một ngăn xếp Lock Free LIFO tầm thường. Những gì bạn làm là có một ngăn xếp "riêng tư" thứ hai cho người tiêu dùng (cũng có thể được thực hiện dưới dạng SLIST cho đơn giản hoặc bất kỳ mô hình ngăn xếp nào khác mà bạn chọn). Người tiêu dùng bật các mục ra khỏi ngăn xếp riêng tư. Bất cứ khi nào LIFO riêng tư được hết, bạn thực hiện Xả thay vì Tắt SLIST đồng thời được chia sẻ (lấy toàn bộ chuỗi SLIST) và sau đó di chuyển danh sách Xả theo thứ tự đẩy các mục vào ngăn xếp riêng.
Điều đó hoạt động cho một nhà sản xuất / một người tiêu dùng và cho nhiều nhà sản xuất / một người tiêu dùng.
Tuy nhiên, nó không hoạt động đối với các trường hợp nhiều người tiêu dùng (với một nhà sản xuất đơn lẻ hoặc nhiều nhà sản xuất).
Ngoài ra, theo như các bảng băm, chúng là một ứng cử viên lý tưởng cho việc "phân chia" tức là chỉ chia băm thành các phân đoạn có khóa trên mỗi phân đoạn của bộ nhớ cache. Đây là cách mà thư viện đồng thời Java thực hiện (sử dụng 32 sọc). Nếu bạn có khóa người đọc-ghi trọng lượng nhẹ, bảng băm có thể được truy cập đồng thời để đọc đồng thời và bạn sẽ chỉ dừng lại khi quá trình ghi xảy ra trên các sọc cạnh tranh (và có thể nếu bạn cho phép phát triển bảng băm).
Nếu bạn tự cuộn, hãy đảm bảo xen kẽ các ổ khóa của mình với các mục nhập băm thay vì đặt tất cả các ổ khóa của bạn trong một mảng cạnh nhau để bạn ít có khả năng bị chia sẻ sai.
Tôi có thể đến hơi muộn về việc này.
Việc không có giải pháp (ở câu hỏi đã được hỏi) chủ yếu là do một vấn đề quan trọng trong C ++ (trước C ++ 0x / 11): C ++ có (có) không có mô hình bộ nhớ đồng thời.
Bây giờ, sử dụng std :: atom, bạn có thể kiểm soát các vấn đề về thứ tự bộ nhớ và có các hoạt động so sánh và hoán đổi thích hợp. Tôi đã tự viết bản triển khai hàng đợi không có khóa của Micheal & Scott (PODC96) bằng cách sử dụng C ++ 11 và Con trỏ nguy hiểm của Micheal (IEEE TPDS 2004) để tránh các vấn đề về ABA và miễn phí sớm. Nó hoạt động tốt nhưng nó thực hiện nhanh chóng và bẩn thỉu và tôi không hài lòng với màn trình diễn thực tế. Mã có sẵn trên bitbucket: LockFreeExperiment
Cũng có thể triển khai hàng đợi không có khóa mà không có con trỏ nguy hiểm bằng cách sử dụng các từ kép CAS (nhưng phiên bản 64bit sẽ chỉ khả dụng trên x86-64 sử dụng cmpxchg16b), tôi đã đăng một bài blog về điều đó (với mã chưa được kiểm tra cho hàng đợi) ở đây : Thực hiện so sánh và hoán đổi từ kép chung cho x86 / x86-64 (blog LSE.)
Điểm chuẩn của riêng tôi cho tôi thấy rằng hàng đợi có khóa kép (cũng trong bài báo của Micheal & Scott 1996) hoạt động tốt như hàng không có khóa (tôi chưa đạt đủ ý kiến để cấu trúc dữ liệu bị khóa có vấn đề về hiệu suất, nhưng băng ghế dự bị của tôi quá nhẹ cho bây giờ) và hàng đợi đồng thời từ TBB của Intel dường như thậm chí còn tốt hơn (nhanh hơn hai lần) với một số lượng tương đối nhỏ (tùy thuộc vào hệ điều hành, trong FreeBSD 9, giới hạn thấp nhất mà tôi tìm thấy cho đến nay, con số này là 8 luồng trên một i7 với 4 ht-core, và do đó là 8 CPU logic) của các luồng và có hành vi rất lạ (thời gian thực thi điểm chuẩn đơn giản của tôi chuyển từ giây sang giờ!)
Một hạn chế khác về hàng đợi không khóa theo kiểu STL: việc có trình vòng lặp trên hàng đợi không khóa không có cảm giác.
Và sau đó Intel Threading Building Blocks ra đời. Và trong một thời gian, nó đã được tốt.
Tái bút: bạn đang tìm kiếm concurrent_queue và concurrent_hash_map
Theo sự hiểu biết tốt nhất của tôi, vẫn chưa có thứ gì như vậy được công bố rộng rãi. Một vấn đề mà người triển khai cần giải quyết là bạn cần một trình cấp phát bộ nhớ không có khóa, tồn tại, mặc dù tôi dường như không thể tìm thấy liên kết ngay bây giờ.
Sau đây là từ bài viết của Herb Sutter về Hàng đợi không khóa đồng thời http://www.drdobbs.com/parallel/writing-a-generalized-concurrent-queue/211601363?pgno=1 . Tôi đã thực hiện một số thay đổi như sắp xếp lại thứ tự của trình biên dịch. Người ta cần GCC v4.4 + để biên dịch mã này.
#include <atomic>
#include <iostream>
using namespace std;
//compile with g++ setting -std=c++0x
#define CACHE_LINE_SIZE 64
template <typename T>
struct LowLockQueue {
private:
struct Node {
Node( T* val ) : value(val), next(nullptr) { }
T* value;
atomic<Node*> next;
char pad[CACHE_LINE_SIZE - sizeof(T*)- sizeof(atomic<Node*>)];
};
char pad0[CACHE_LINE_SIZE];
// for one consumer at a time
Node* first;
char pad1[CACHE_LINE_SIZE
- sizeof(Node*)];
// shared among consumers
atomic<bool> consumerLock;
char pad2[CACHE_LINE_SIZE
- sizeof(atomic<bool>)];
// for one producer at a time
Node* last;
char pad3[CACHE_LINE_SIZE
- sizeof(Node*)];
// shared among producers
atomic<bool> producerLock;
char pad4[CACHE_LINE_SIZE
- sizeof(atomic<bool>)];
public:
LowLockQueue() {
first = last = new Node( nullptr );
producerLock = consumerLock = false;
}
~LowLockQueue() {
while( first != nullptr ) { // release the list
Node* tmp = first;
first = tmp->next;
delete tmp->value; // no-op if null
delete tmp;
}
}
void Produce( const T& t ) {
Node* tmp = new Node( new T(t) );
asm volatile("" ::: "memory"); // prevent compiler reordering
while( producerLock.exchange(true) )
{ } // acquire exclusivity
last->next = tmp; // publish to consumers
last = tmp; // swing last forward
producerLock = false; // release exclusivity
}
bool Consume( T& result ) {
while( consumerLock.exchange(true) )
{ } // acquire exclusivity
Node* theFirst = first;
Node* theNext = first-> next;
if( theNext != nullptr ) { // if queue is nonempty
T* val = theNext->value; // take it out
asm volatile("" ::: "memory"); // prevent compiler reordering
theNext->value = nullptr; // of the Node
first = theNext; // swing first forward
consumerLock = false; // release exclusivity
result = *val; // now copy it back
delete val; // clean up the value
delete theFirst; // and the old dummy
return true; // and report success
}
consumerLock = false; // release exclusivity
return false; // report queue was empty
}
};
int main(int argc, char* argv[])
{
//Instead of this Mambo Jambo one can use pthreads in Linux to test comprehensively
LowLockQueue<int> Q;
Q.Produce(2);
Q.Produce(6);
int a;
Q.Consume(a);
cout<< a << endl;
Q.Consume(a);
cout<< a << endl;
return 0;
}
Tôi đã tìm thấy một giải pháp khác được viết bằng c:
Tôi đã viết điều này vào một thời điểm nào đó có thể là vào năm 2010, tôi chắc chắn với sự trợ giúp từ các tài liệu tham khảo khác nhau. Nó đa sản xuất một người tiêu dùng.
template <typename T>
class MPSCLockFreeQueue
{
private:
struct Node
{
Node( T val ) : value(val), next(NULL) { }
T value;
Node* next;
};
Node * Head;
__declspec(align(4)) Node * InsertionPoint; //__declspec(align(4)) forces 32bit alignment this must be changed for 64bit when appropriate.
public:
MPSCLockFreeQueue()
{
InsertionPoint = new Node( T() );
Head = InsertionPoint;
}
~MPSCLockFreeQueue()
{
// release the list
T result;
while( Consume(result) )
{
//The list should be cleaned up before the destructor is called as there is no way to know whether or not to delete the value.
//So we just do our best.
}
}
void Produce( const T& t )
{
Node * node = new Node(t);
Node * oldInsertionPoint = (Node *) InterLockedxChange((volatile void **)&InsertionPoint,node);
oldInsertionPoint->next = node;
}
bool Consume( T& result )
{
if (Head->next)
{
Node * oldHead = Head;
Head = Head->next;
delete oldHead;
result = Head->value;
return true;
}
return false; // else report empty
}
};