要實現一個線程安全的RingBuffer，可以使用互斥鎖（mutex）來保護讀寫操作。具體的實現方法如下：

#include <mutex>
#include <condition_variable>
#include <atomic>
#include <vector>

template <typename T>
class RingBuffer {
public:
    RingBuffer(size_t size) : buffer(size), head(0), tail(0), count(0) {}

    void push(const T& item) {
        std::unique_lock<std::mutex> lock(mutex);
        not_full.wait(lock, [this]{ return count < buffer.size(); });
        
        buffer[tail] = item;
        tail = (tail + 1) % buffer.size();
        ++count;
        
        not_empty.notify_one();
    }

    T pop() {
        std::unique_lock<std::mutex> lock(mutex);
        not_empty.wait(lock, [this]{ return count > 0; });

        T item = buffer[head];
        head = (head + 1) % buffer.size();
        --count;

        not_full.notify_one();

        return item;
    }

private:
    std::vector<T> buffer;
    size_t head;
    size_t tail;
    size_t count;

    std::mutex mutex;
    std::condition_variable not_full;
    std::condition_variable not_empty;
};

在上面的代碼中，使用了std::mutex來保護對RingBuffer的讀寫操作。在push和pop方法中，使用了std::unique_lock來加鎖，并在需要的時候通過條件變量（std::condition_variable）等待或喚醒線程。這樣就可以保證多個線程對RingBuffer的操作是線程安全的。