std::thread...too little, too late?

I was looking at what made its way into the C++11 standard in the way of
threads, and it seems very braindead. I mean third party libraries have
been giving us working threading for years, and "THAT"was all they came
up with for the standard?

I fully understand the implications of adding features that need to be
portable and that give a good least common denominator, but std::thread
seems too little, too late.

I thought it would be easy to at least build upon the std::thread class
and to something that more closely resembles the common threading utility
available in a variety of libraries: something with delayed thread
starting, and the ability to make the process OO with a virtual run()
method...no such luck.

Consider the following example that uses std::thread as a class trait and
then subclasses a UsefulThread class, adding the requested functionality:

class UsefulThread {
    thread* stdThread;
public:
    UsefulThread();
    virtual ~UsefulThread() { delete stdThread; }
    virtual void run()=0;
    void start() { stdThread=new thread(run); }
    void join() { stdThread->join(); }
};

class WorkerThread: public UsefulThread {
    int _id;
    BufferObject& r;
public:
    WorkerThread(int id, BufferObject& b): UsefulThread(), _id(id), r(b)
{}
    virtual void run() { for (auto i=0; i<_id; i++) r << _id; }
        // share r object is made threadsafe with an internal mutex
};

int main(int argc, char** argv) {
    using namespace std;
    list<int> v ={1, 2, 3, 4, 5, 6, 7, 8, 9};
    BufferObject b;
    list<WorkerThread> threadList;
    for (auto i: v) { WorkerThread t(i, b); threadList.push_back(t); };
    for (auto i: threadList) i.start();
    for (auto i: threadList) i.join();
    
    cout << b.str() << endl;

    return 0;
}

There is no way (that I can tell of) to make the UsefulThread::start()
method properly register the run() virtual. There was an article online
at <http://rafalcieslak.wordpress.com/2014/05/16/c11-stdthreads-managed-
by-a-designated-class/> where the author tries to address the delayed
start issue. Problem is that 1) he doesn't allow for a virtual run()
method, and 2) when using a normal thread object instead of a thread* the
resulting WorkerThread cannot be put into any sort of std container, and
gives compile errors about (use of deleted function) from the constructor.