C++11 Threads

I was just brushing up on some C++11 concepts the last few nights (looking for parts of the engine to improve) and noticed quite a few people struggling with threads inside classes, as in using a class object as a thread. Some of the responses were so confusing to say the least.

Also they were struggling with std::cout while threads were running. So here's some example code of these problems all in one. I hope it points someone in the right direction.

Files:
lsThread2.h / .cpp
lsThread.h / .cpp
core.h / .cpp
main.cpp

// file : core.h

#ifndef cppThreads_core_h
#define cppThreads_core_h

#include <iostream>
#include <vector>
#include <thread>
#include <mutex>

using namespace std;

/*! Base class
 Used to start some lsThread objects.
 */
class core
{
public:
    core();
    virtual ~core();
    
    void run();
    void logText( const string& val, int tid  );
    
private:
    int nr_threads;
    mutex m;
};


#endif

// file : core.cpp
​
#include "core.h"
#include "lsThread.h"

core::core()
{
    nr_threads = 10;
}

core::~core()
{
}

void core::run()
{
    cout << "########## Start test ##########" << endl;
    
    vector<thread> th;
    lsThread *mt = new lsThread[nr_threads];
    
    //Launch a group of threads
    for( int i = 0; i < nr_threads; ++i )
    {
        mt[i].setTid( i );
        // Shows how to pass args to the start function in lsThread
        th.push_back( thread( &lsThread::start, mt[i], this, 5 ) );
    }
    
    //Join the threads with the main thread which core is running
    for( auto &t : th )
    {
        t.join();
    }
    
    // delete our array of lsThread objects
    delete [] mt;
    cout << "########## End test ##########" << endl;
}

/*! Logging
 This function is here so its in a common thread for all other threads to call.
 Remember in a real world App you would make a better logger.
 */
void core::logText( const string& val, int tid )
{
    // Lock for output
    m.lock();
    cout << "Thread : " << tid << " - " << val << endl;
    m.unlock();
}

Above: a base class that runs in the main thread.

// file : lsThread.h
​
#ifndef cppThreads_lsThread_h
#define cppThreads_lsThread_h

#include <iostream>
#include <thread>
#include <vector>

class core;

using namespace std;

/*! Thread class
 Nothing special about this class, you could thread any class.
 */
class lsThread
{
public:
    lsThread();
    virtual ~lsThread();
    
    virtual void start( core *c, int val );
    
    void setTid( int val )
    {
        tid = val;
    }
    
private:
    int tid;
    
};


#endif

// File : lsThread.cpp

#include "core.h"
#include "lsThread.h"
#include "lsThread2.h"

lsThread::lsThread()
{
    tid = 0;
}

lsThread::~lsThread()
{
}

void lsThread::start( core *c, int val )
{
    c->logText( "lsThread start", tid );
    
    // Here we create some more threads with a new class, based on the passed value.
    vector<thread> th;
    int nr_threads = val;
    lsThread2 *mt = new lsThread2[nr_threads];
    
    //Launch a group of threads
    for( int i = 0; i < nr_threads; ++i )
    {
        mt[i].setTid( i );
        th.push_back( thread( &lsThread2::start, mt[i], c ) );
    }
    
    // Join the threads with the current thread
    // This could be any of the threads created by the core class.
    for( auto &t : th )
    {
        t.join();
    }
    
    // delete our array of lsThread2 objects.
    delete [] mt;
}

Above: This class show how to launch more threads inside the current thread.

// File : lsThread2.h

#ifndef cppThreads_lsThread2_h
#define cppThreads_lsThread2_h

#include <iostream>
#include <thread>
#include <vector>

class core;

using namespace std;

class lsThread2
{
public:
    lsThread2();
    virtual ~lsThread2();
    
    virtual void start( core *c );
    
    void setTid( int val )
    {
        tid = val;
    }
    
private:
    int tid;
};


#endif

// File : lsThread2.cpp

#include "core.h"
#include "lsThread2.h"


lsThread2::lsThread2()
{
    tid = 0;
}

lsThread2::~lsThread2()
{
}

void lsThread2::start( core *c )
{
    // In this thread we just call the core class logging function
    c->logText( "lsThread2 start", tid );
}

Above: Simple thread that will just output a message to stdout.

// File : main.cpp

#include "core.h"


int main(int argc, const char * argv[])
{
    // Thread demo
    core *c = new core();
    c->run();
    delete c;
    
    return 0;
}

Above: And last but not least the main()

I've kept this example as simple as possible but still trying to show as much as possible. Hope it helps someone.

Cheers
Lee