Vector и thread-safe

#pragma once
#include <vector>
 
template<typename T>
class SafeArray()
{
private:
    std::vector< T*> Array;
 
public:
    SafeArray();
    ~SafeArray();
 
    /// как защитить мой контейнер вектор чтоб его потоки не порвали когда будут одновременно 
    /// добавлять удалять и так далее
    size_t SafeArray()::size(){ Array.size(); }
 
    void SafeArray()::push();
    void SafeArray()::clear(){ Array.clear(); }
    //.... и так далее разные функции.
}

#include <iostream>
#include <memory>
#include <mutex>
#include <condition_variable>
#include <thread>
#include <chrono>
#include <queue>
#include <algorithm>
#include <functional>
#include <utility>
 
template <typename T>
class threadsafe_queue
{
    mutable std::mutex mut;
    std::queue<T> data;
 
    bool has_el(std::queue<T> qu, T &&value) const
    {
        while (!qu.empty()) {
            if (value == qu.front()) return true;
            qu.pop();
        }
        return false;
    }
 
    bool add_unique_el(T &&t)
    {
        if (has_el(data, std::forward<T>(t)))
            return false;
        else {
            data.push(std::forward<T>(t));
            return true;
        }
    }
 
public:
    threadsafe_queue() = default;
    threadsafe_queue(threadsafe_queue const& other) = delete;
    threadsafe_queue & operator =(threadsafe_queue const& other) = delete;
 
    threadsafe_queue(threadsafe_queue && other) = default;
    threadsafe_queue & operator =(threadsafe_queue && other) = default;
 
    std::size_t size() const
    {
        std::lock_guard<std::mutex> locker(mut);
        return data.size();
    }
 
    void swap(threadsafe_queue & other) noexcept(noexcept(std::swap(data, other.data)))
    {
        using std::swap;
 
        std::lock_guard<std::mutex> locker(mut);
        swap(data, other.data);
    }
 
    bool push(T &&new_value)
    {
        std::lock_guard<std::mutex> locker(mut);
        return add_unique_el(std::forward<T>(new_value));
    }
 
    bool push(const T &new_value)
    {
        std::lock_guard<std::mutex> locker(mut);
        return add_unique_el(T(new_value));
    }
 
    void pop()
    {
        std::lock_guard<std::mutex> locker(mut);
        data.pop();
    }
 
    T& front()
    {
        std::lock_guard<std::mutex> locker(mut);
        if ( !data.empty() )
            return data.front();
    }
 
    T& back()
    {
        std::lock_guard<std::mutex> locker(mut);
        if ( !data.empty() )
            return data.back();
    }
 
    const T& front() const
    {
        std::lock_guard<std::mutex> locker(mut);
        if ( !data.empty() )
            return data.front();
    }
 
    const T& back() const
    {
        std::lock_guard<std::mutex> locker(mut);
        if ( !data.empty() )
            return data.back();
    }
 
    template< class... Args >
    void emplace(Args&&... args)
    {
        std::lock_guard<std::mutex> locker(mut);
        return add_unique_el(T(std::forward<Args>(args)...));
    }
 
    bool empty() const noexcept
    {
        std::lock_guard<std::mutex> locker(mut);
        return data.empty();
    }
 
    void print_queue(std::ostream& os = std::cout)
    {
        std::lock_guard<std::mutex> locker(mut);
        std::queue<T> temp(data);
 
        while (!temp.empty()) {
            os << temp.front() << " ";
            temp.pop();
        }
        os << std::endl;
    }
};
 
 
////////////////////////////////////////////////////////
 
void prepare_data(threadsafe_queue<int>& q)
{
    while(true)
    {
        for (int i = 0; i < 5; ++i)
        {
            q.push(i);
            q.push(i);
            q.push(i);
        }
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
}
 
void processing_data(threadsafe_queue<int>& q, int id)
{
    while(true)
    {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        std::cout << "Thread: " << id << ", val: "; 
q.print_queue();
    }
}
 
int main()
{
    threadsafe_queue <int> test;
 
    std::thread t_q1 (prepare_data, std::ref(test));
    std::thread t_q2 (prepare_data, std::ref(test));
    std::thread t_q3 (prepare_data, std::ref(test));
    std::thread t_q4 (prepare_data, std::ref(test));
    std::thread t_q5 (prepare_data, std::ref(test));
    std::thread t_q6 (prepare_data, std::ref(test));
    std::thread t_q7 (prepare_data, std::ref(test));
    std::thread t_q8 (prepare_data, std::ref(test));
    std::thread t1(processing_data, std::ref(test), 1);
    std::thread t2(processing_data, std::ref(test), 2);
 
    t_q1.join();
    t_q2.join();
    t_q3.join();
    t_q4.join();
    t_q5.join();
    t_q6.join();
    t_q7.join();
    t_q8.join();
 
    t1.join();
    t2.join();
 
    std::cout << "\n\nDone.\n";
}

    while(true)
    {
        for (int i = 0; i < 5; ++i)
        {
            q.push(i);
            q.push(i);
            q.push(i);
        }
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }