Простой пример многопоточности в C ++

Создайте функцию, которую вы хотите, чтобы поток выполнялся, например:

void task1(std::string msg)
{
    std::cout << "task1 says: " << msg;
}

Теперь создайте объект thread, который в конечном итоге вызовет указанную выше функцию следующим образом:

std::thread t1(task1, "Hello");

(Вам необходимо #include <thread>, чтобы получить доступ к классу std::thread)

Аргументы конструктора - это функция, которую будет выполнять поток, за которой следуют параметры функции. Поток запускается автоматически при построении.

Если позже вы захотите дождаться, пока поток завершит выполнение функции, вызовите:

t1.join(); 

(Присоединение означает, что поток, который вызвал новый поток, будет ждать, пока новый поток завершит выполнение, прежде чем он продолжит собственное выполнение).

Код

#include <string>
#include <iostream>
#include <thread>

using namespace std;

// The function we want to execute on the new thread.
void task1(string msg)
{
    cout << "task1 says: " << msg;
}

int main()
{
    // Constructs the new thread and runs it. Does not block execution.
    thread t1(task1, "Hello");

    // Do other things...

    // Makes the main thread wait for the new thread to finish execution, therefore blocks its own execution.
    t1.join();
}

Подробнее о std :: thread здесь

• В GCC компилируйте с -std=c++0x -pthread.
• Это должно работать для любой операционной системы, если ваш компилятор поддерживает эту функцию (C ++ 11).

Что ж, технически любой такой объект будет построен на основе библиотеки потоков в стиле C, потому что в C ++ только что указан stock _ 1_ в c ++ 0x, которая была только что прибита и еще не реализована. Проблема носит в некоторой степени системный характер, технически существующая модель памяти C ++ недостаточно строгая, чтобы обеспечить четко определенную семантику для всех случаев, когда «произошло раньше». Некоторое время назад Ханс Бём написал статью по этой теме и сыграл важную роль в разработке стандарта C ++ 0x по этой теме.

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

Тем не менее, существует несколько библиотек C ++ для кросс-платформенных потоков, которые на практике прекрасно работают. Строительные блоки Intel thread содержат объект tbb :: thread, который близко приближается к стандарту c ++ 0x, а Boost имеет библиотеку boost :: thread, которая делает то же самое.

http://www.threadingbuildingblocks.org/

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

Используя boost :: thread, вы получите что-то вроде:

#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;
}

Также существует библиотека POSIX для операционных систем POSIX. Проверить совместимость

#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;

}

скомпилировать с -lpthread

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

При поиске примера класса C ++, который вызывает один из своих собственных методов экземпляра в новом потоке, возникает этот вопрос, но мы не смогли использовать ни один из этих ответов таким образом. Вот пример, который это делает:

Class.h

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

Class.cpp

#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
    }
}

Обратите внимание, что в этом примере не рассматривается мьютекс или блокировка.

Если не нужна отдельная функция в глобальных пространствах имен, мы можем использовать лямбда-функции для создания потоков.

Одним из основных преимуществ создания потока с использованием лямбда является то, что нам не нужно передавать локальные параметры в качестве списка аргументов. Мы можем использовать список захвата для того же самого, и свойство закрытия лямбда позаботится о жизненном цикле.

Вот пример кода

int main() {
    int localVariable = 100;

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

    th.join();

    return 0;
}

Безусловно, я обнаружил, что лямбда-выражения C ++ - лучший способ создания потоков, особенно для более простых потоковых функций.

Это во многом зависит от библиотеки, которую вы решите использовать. Например, если вы используете библиотеку wxWidgets, создание потока будет выглядеть так:

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;
}

Если ваш основной поток вызывает метод CreateThread, вы создадите новый поток, который начнет выполнение кода в вашем методе «Entry». В большинстве случаев вам нужно будет сохранить ссылку на поток, чтобы присоединиться к нему или остановить его. Дополнительная информация здесь: документация wxThread