Prosty przykład gwintowania w C++

Cóż, technicznie każdy taki obiekt zostanie zbudowany nad biblioteką wątków w stylu C, ponieważ C++ dopiero co określił stock std::thread model w c++0x, który właśnie został przybity i nie został jeszcze zaimplementowany. Problem jest nieco systemowy, technicznie istniejący model pamięci c++ nie jest wystarczająco ścisły, aby pozwolić na dobrze zdefiniowaną semantykę dla wszystkich przypadków "happens before". Hans Boehm napisał artykuł na ten temat jakiś czas temu i odegrał kluczową rolę w tworzeniu c++0x standard w temacie.

Http://www.hpl.hp.com/techreports/2004/HPL-2004-209.html

To powiedziawszy, istnieje kilka wieloplatformowych bibliotek thread C++, które działają dobrze w praktyce. Intel thread building blocks zawiera obiekt TBB:: thread, który jest zbliżony do standardu c++0x, a Boost ma bibliotekę boost::thread, która to samo.

Http://www.threadingbuildingblocks.org/

Http://www.boost.org/doc/libs/1_37_0/doc/html/thread.html

Używając boost:: thread otrzymałbyś coś w stylu:

#include <boost/thread.hpp>

void task1() { 
    // do stuff
}

void task2() { 
    // do stuff
}

int main (int argc, char ** argv) {
    using namespace boost; 
    thread thread_1 = thread(task1);
    thread thread_2 = thread(task2);

    // do other stuff
    thread_2.join();
    thread_1.join();
    return 0;
}

Istnieje również biblioteka POSIX dla systemów operacyjnych POSIX. Sprawdź na zgodność

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <iostream>

void *task(void *argument){
      char* msg;
      msg = (char*)argument;
      std::cout<<msg<<std::endl;
}

int main(){
    pthread_t thread1, thread2;
    int i1,i2;
    i1 = pthread_create( &thread1, NULL, task, (void*) "thread 1");
    i2 = pthread_create( &thread2, NULL, task, (void*) "thread 2");

    pthread_join(thread1,NULL);
    pthread_join(thread2,NULL);
    return 0;

}

Skompiluj z-lpthread

Http://en.wikipedia.org/wiki/POSIX_Threads

To w dużej mierze zależy od biblioteki, z której zdecydujesz się korzystać. Na przykład, jeśli używasz biblioteki wxWidgets, utworzenie wątku wyglądałoby tak:

class RThread : public wxThread {

public:
    RThread()
        : wxThread(wxTHREAD_JOINABLE){
    }
private:
    RThread(const RThread &copy);

public:
    void *Entry(void){
        //Do...

        return 0;
    }

};

wxThread *CreateThread() {
    //Create thread
    wxThread *_hThread = new RThread();

    //Start thread
    _hThread->Create();
    _hThread->Run();

    return _hThread;
}

Jeśli główny wątek wywoła metodę CreateThread, utworzysz nowy wątek, który rozpocznie wykonywanie kodu w Twojej metodzie "Entry". W większości przypadków będziesz musiał zachować odniesienie do wątku, aby go dołączyć lub zatrzymać. Więcej informacji tutaj: wxthread documentation

Oto bardziej rozbudowany sposób tworzenia dowolnej liczby wątków (w C++11 lub nowszym):

#include <thread>
#include <iostream>
using namespace std;

void doSomething(int id) {
    cout << "Thread id = " << id;
}

/**
 * Spawns n threads
 */
void spawnThreads(int n)
{
    thread threads[n];
    // spawn n threads:
    for (int i = 0; i < n; i++) {
        threads[i] = thread(doSomething, i + 1);
    }

    for (auto& th : threads) {
        th.join();
    }
}

Szukając przykładu klasy C++, która w nowym wątku wywołuje jedną ze swoich własnych metod instancji, pojawia się to pytanie, ale nie byliśmy w stanie użyć żadnej z tych odpowiedzi w ten sposób. Oto przykład, który to robi:

class DataManager
{
public:
    bool hasData;
    void getData();
    bool dataAvailable();
};

#include "DataManager.h"

void DataManager::getData()
{
    // perform background data munging
    hasData = true;
    // be sure to notify on the main thread
}

bool DataManager::dataAvailable()
{
    if (hasData)
    {
        return true;
    }
    else
    {
        std::thread t(&DataManager::getData, this);
        t.detach(); // as opposed to .join, which runs on the current thread
    }
}

Zauważ, że ten przykład nie wchodzi w mutex lub locking.

Jeśli nie chcemy oddzielnej funkcji w globalnych nazwach, możemy używać funkcji lambda do tworzenia wątków.

Jedną z głównych zalet tworzenia wątków przy użyciu lambda jest to, że nie musimy przekazywać lokalnych parametrów jako listy argumentów. Możemy użyć capture list dla tego samego, a właściwość closure lambda zajmie się cyklem życia.

Oto przykładowy kod

int main() {
    int localVariable = 100;

    thread th { [=](){
        cout<<"The Value of local variable => "<<localVariable<<endl;
    }}

    th.join();

    return 0;
}

Jak na razie uważam, że C++ lambda jest najlepszym sposobem tworzenia wątków szczególnie dla prostsze funkcje wątków