I am trying to implement a multi threaded application with pthread. I did implement a thread class which looks like the following and I call it later twice (or even more), but it seems to block instead of execute the threads parallel.

Here is what I got until now: The Thread Class is an abstract class which has the abstract method "exec" which should contain the thread code in a derive class (I did a sample of this, named DerivedThread)

Thread.hpp

#ifndef THREAD_H_
#define THREAD_H_

#include <pthread.h>

class Thread {
public:
       Thread();
       void start();
       void join();

       virtual int exec() = 0;
       int exit_code();
private:
       static void* thread_router(void* arg);
       void exec_thread();
       pthread_t pth_;
       int code_;
};

#endif /* THREAD_H_ */

And Thread.cpp

#include <iostream>
#include "Thread.hpp"

/*****************************/

using namespace std;

Thread::Thread(): code_(0) {
    cout << "[Thread] Init" << endl;
}

void Thread::start() {
    cout << "[Thread] Created Thread" << endl;
     pthread_create( &pth_,
                     NULL,
                     Thread::thread_router,
                     reinterpret_cast<void*>(this));
}

void Thread::join() {
    cout << "[Thread] Join Thread" << endl;
    pthread_join(pth_, NULL);
}

int Thread::exit_code() {
    return code_;
}

void Thread::exec_thread() {
    cout << "[Thread] Execute" << endl;
    code_ = exec();
}

void* Thread::thread_router(void* arg) {
    cout << "[Thread] exec_thread function in thread" << endl;
    reinterpret_cast<Thread*>(arg)->exec_thread();
    return NULL;
}

DerivedThread.hpp

#include "Thread.hpp"

class DerivedThread : public Thread {
public:
DerivedThread();
virtual ~DerivedThread();

int exec();
void Close() = 0;

DerivedThread.cpp

[...]

#include "DerivedThread.cpp"

[...]

int DerivedThread::exec() {
    //code to be executed
    do {
        cout << "Thread executed" << endl;
        usleep(1000000);
    } while (true); //dummy, just to let it run for a while
}

[...]

Basically, I am calling this like the here:

DerivedThread *thread;
cout << "Creating Thread" << endl;
thread = new DerivedThread();
cout << "Created thread, starting..." << endl;
thread->start();
cout << "Started thread" << endl;

cout << "Creating 2nd Thread" << endl;
thread = new DerivedThread();
cout << "Created 2nd thread, starting..." << endl;
thread->start();
cout << "Started 2nd thread" << endl;

What is working great if I am only starting one of these Threads , but if I start multiple which should run together (not synced, only parallel) . But I discovered, that the thread is created, then as it tries to execute it (via start) the problem seems to block until the thread has closed. After that the next Thread is processed.

I thought that pthread would do it unblocked for me, so what did I wrong?

A sample output might be:

Creating Thread
[Thread] Thread Init
Created thread, starting...
[Thread] Created thread
[Thread] exec_thread function in thread
[Thread] Execute
Thread executed
Thread executed
Thread executed
Thread executed
Thread executed
Thread executed
Thread executed
....

Until Thread 1 is not terminated, a Thread 2 won't be created not executed.

The process above is executed in an other class. Just for the information: I am trying to create a multi threaded server. The concept is like this:

MultiThreadedServer Class has a main loop, like this one:

::inet::ServerSock *sock; //just a simple self made wrapper class for sockets
DerivedThread *thread;

for (;;) {
    sock = new ::inet::ServerSock();
    this->Socket->accept( *sock );
    cout << "Creating Thread" << endl;  //Threads (according to code sample above)
    thread = new DerivedThread(sock);   //I did not mentoine the parameter before as it was not neccesary, in fact, I pass the socket handle with the connected socket to the thread
    cout << "Created thread, starting..." << endl;
    thread->start();
    cout << "Started thread" << endl;   
}

So I thought that this would loop over and over and wait for new connections to accept. and when a new client arrives, I am creating a new thread and give the thread the connected socket as a parameter.

In the DerivedThread::exec I am doing the handling for the connected client. Like: [...] do { [...] if (this->sock_->read( Buffer, sizeof(PacketStruc) ) > 0) { cout << "[Handler_Base] Recv Packet" << endl; //handle the packet } else { Connected = false; } delete Buffer; } while ( Connected );

So I loop in the created thread as long as the client keeps the connection.

I think, that the socket may cause the blocking behaviour.

Edit:

I figured out, that it is not the read() loop in the DerivedThread Class as I simply replaced it with a loop over a simple cout-usleep part. It did also only execute the first one and after first thread finished, the 2nd one was executed.

Many thanks and best regards, Sebastian