Static member with static mutex and thread-safety

I have a template class similar to this one:

template <typename T>
class Foo {
    public:
        static void show () { 
            unique_lock<mutex> l {mtx};
            for (const auto& v : vec) {
                cout << v << endl;
            }
        }

        static void add (T s) { 
            unique_lock<mutex> l {mtx};
            vec.push_back (s);
        }

    private:
        static mutex mtx;
        static vector<T> vec;
};

template <typename T> mutex Foo<T>::mtx;
template <typename T> vector<T> Foo<T>::vec;

And usage of this class looks like this:

Foo<string>::add ("d");
Foo<string>::add ("dr");
Foo<string>::add ("dre");
Foo<string>::add ("drew");
Foo<string>::show ();

Could you tell me if this class is thread-safe? And if it is not, how to make a thread safe version?

If I understand it correctly when we have a class with member functions (not static) and mutex (not static), we prevent race condition of the single object which has been passed across threads, right? And when we have something similar to this we prevent race condition not for the object but for the class instead - in this case for particular type, or am I wrong?