Most basic parallelization with C++11 theads fail

Question

I try to use C++11 theading library using g++ 4.7. First I have a question: is it expected for a next release to not be required to link by hand the pthread library ?

So my program is :

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

void f(int i) {
    std::cout<<"Hello world from : "<<i<<std::endl;
}

int main() {
    const int n = 4;
    std::vector<std::thread> t;
    for (int i = 0; i < n; ++i) {
        t.push_back(std::thread(f, i));
    }
    for (int i = 0; i < n; ++i) {
        t[i].join();
    }
    return 0;
}

I compile with:

g++-4.7 -Wall -Wextra -Winline -std=c++0x -pthread -O3 helloworld.cpp -o helloworld

And it returns:

Hello world from : Hello world from : Hello world from : 32
2
pure virtual method called

terminate called without an active exception
Erreur de segmentation (core dumped)

What is the problem and how to solve it ?

UPDATE:

Now using mutex:

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

static std::mutex m;

void f(int i) {
    m.lock();
    std::cout<<"Hello world from : "<<i<<std::endl;
    m.unlock();
}

int main() {
    const int n = 4;
    std::vector<std::thread> t;
    for (int i = 0; i < n; ++i) {
        t.push_back(std::thread(f, i));
    }
    for (int i = 0; i < n; ++i) {
        t[i].join();
    }
    return 0;
}

It returns :

pure virtual method called
Hello world from : 2
terminate called without an active exception
Abandon (core dumped)

UPDATE 2: Hum... It works with my default GCC (g++4.6) but it fails with the version of gcc I compiled by hand (g++4.7.1). Was there an option I forgot to compile g++ 4.7.1 ?

Answer 1

General edit:

In order to prevent use of cout by multiple threads simultaneously, that will result in character interleaving, proceed as follows:

1) declare before the declaration of f():

static std::mutex m;

2) then, guard the "cout" line between:

m.lock();
std::cout<<"Hello world from : "<<i<<std::endl;
m.unlock();

Apparently, linking against the -lpthread library is a must, for some unclear reasons. At least on my machine, not linking against -lpthread results in a core dump. Adding -lpthread results in proper functionality of the program.

The possibility of character interleaving if locking is not used when accessing cout from different threads is expressed here:

https://stackoverflow.com/a/6374525/1284631

more exactly: "[ Note: Users must still synchronize concurrent use of these objects and streams by multiple threads if they wish to avoid interleaved characters. — end note ]"

OTOH, the race condition is guaranteed to be avoided, at least in the C++11 standard (beware, the gcc/g++ implementation of this standard is still at experimental level).

Note that the Microsoft implementation (see: http://msdn.microsoft.com/en-us/library/c9ceah3b.aspx credit to @SChepurin) is stricter than the standard (apparently, it guarantees character interleaving is avoided), but this might not be the case for the gcc/g++ implementation.

This is the command line that I use to compile (both updated and original code versions, everything works well on my PC):

g++ threadtest.cpp -std=gnu++11 -lpthread -O3

OTOH, without the -lpthread, it compiles but I have a core dump (gcc 4.7.2 on Linux 64).

I understand that you are using two different versions of the gcc/g++ compiler on the same machine. Just be sure that you use them properly (not mixing different library versions).