Re: 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.