#include #include #include #include using namespace std; template class terra_spin_queue { public: typedef typename std::queue queue

以下是使用C++11提供的原子操作和无锁队列实现的优化代码：

#include #include #include #include

using namespace std;

template class terra_spin_queue { public:

void push(const T& value)
{
    while (true)
    {
        T* expected_tail = m_tail.load(memory_order_relaxed);
        if (m_tail.compare_exchange_weak(expected_tail, new T(value)))
        {
            expected_tail->next = nullptr;
            atomic_thread_fence(memory_order_release);
            m_tail.store(expected_tail->next, memory_order_relaxed);
            break;
        }
    }
}

bool try_pop(T& result)
{
    while (true)
    {
        T* expected_head = m_head.load(memory_order_relaxed);
        T* expected_tail = m_tail.load(memory_order_relaxed);

        if (expected_head == expected_tail) // queue is empty
            return false;

        T* expected_next = expected_head->next;

        if (m_head.compare_exchange_weak(expected_head, expected_next))
        {
            result = *expected_head;
            atomic_thread_fence(memory_order_acquire);
            delete expected_head;
            expected_head = nullptr;
            return true;
        }
    }
}

protected:

struct node
{
    T data;
    node* next;
    node(const T& value) : data(value), next(nullptr){}
};

atomic<node*> m_head;
atomic<node*> m_tail;

};

struct ttt {

char a[12];
int b;

}; static terra_spin_queue global_queue;

void workTrheadFunc() {

int v=0;
while (true)
{
    ttt* val = new ttt;
    val->b = v++;
    global_queue.push(val);
    // std::this_thread::sleep_for(std::chrono::nanoseconds(1));
}

}

int main() {

thread workThread(workTrheadFunc);
while (true)
{
    ttt* i;
    if(global_queue.try_pop(i))
    {
        cout << "Consumer: " << i->b << endl;
        delete i;
        i = nullptr;
    }
}
workThread.join();

}