Давайте посмотрим на лес сначала, прежде чем смотреть на деревья.
Здесь есть много информативных ответов с большими подробностями, я не буду повторять ни одного из них. Ключ к программированию в JavaScript имеет сначала правильную ментальную модель общего исполнения.
Хорошие новости заключается в том, что, если вы хорошо понимаете этот момент, вам никогда не придется беспокоиться о гоночных условиях. Прежде всего вы должны понимать, как вы хотите упорядочить свой код как по существу ответ на разные дискретные события, и как вы хотите объединить их в логическую последовательность. Вы можете использовать обещания или новые асинхронные / ожидающие более высокие уровни в качестве инструментов для этой цели, или вы можете откатывать свои собственные.
Но вы не должны использовать какие-либо тактические инструменты для решения проблемы, пока вам не понравится актуальная проблемная область. Нарисуйте карту этих зависимостей, чтобы знать, что нужно запускать, когда. Попытка ad-hoc подхода ко всем этим обратным вызовам просто не поможет вам.
#include <thread>
#include <iostream>
class bar {
public:
void foo() {
std::cout << "hello from member function" << std::endl;
}
};
int main()
{
std::thread t(&bar::foo, bar());
t.join();
}
EDIT: Учет вашего редактирования, вы должны сделать это следующим образом:
std::thread spawn() {
return std::thread(&blub::test, this);
}
UPDATE: я хочу объяснить несколько пунктов, некоторые из них также обсуждались в комментариях.
Синтаксис, описанный выше, определен в терминах определения INVOKE (§20.8.2.1):
Определить INVOKE (f, t1, t2,. .., tN) следующим образом:
blockquote>
- (t1. * f) (t2, ..., tN), когда f является указателем на функцию-член класса T и t1 является объект типа T или ссылку на объект типа T или ссылку на объект типа, полученного из T;
- ((* t1). * f) (t2, ..., tN ), когда f является указателем на функцию-член класса T и t1 не является одним из типов, описанных в предыдущем пункте;
- t1. * f, когда N == 1 и f является указателем на данные члена класса T и t 1 являются объектами типа T или ссылкой на объект типа T или ссылкой на объект типа, полученного из T;
- (* t1). * f, когда N == 1 и f является указателем на данные элемента класса T и t 1 не является один из типов, описанных в предыдущем пункте:
- f (t1, t2, ..., tN) во всех других случаях.
Еще один общий факт, который я хочу отметить, заключается в том, что по умолчанию конструктор потока копирует все переданные ему аргументы. Причина этого в том, что аргументам может потребоваться пережить вызывающий поток, и копирование аргументов гарантирует это. Вместо этого, если вы хотите действительно передать ссылку, вы можете использовать
std::reference_wrapper
, созданныйstd::ref
.std::thread (foo, std::ref(arg1));
Поступая таким образом, вы обещаете, что будете заботиться о том, чтобы аргументы будут существовать, когда поток работает на них.
Обратите внимание, что все перечисленные выше могут также применяться к
std::async
иstd::bind
.
@ hop5 и @RnMss предложили использовать C ++ 11 lambdas, но если вы имеете дело с указателями, вы можете использовать их напрямую:
#include <thread>
#include <iostream>
class CFoo {
public:
int m_i = 0;
void bar() {
++m_i;
}
};
int main() {
CFoo foo;
std::thread t1(&CFoo::bar, &foo);
t1.join();
std::thread t2(&CFoo::bar, &foo);
t2.join();
std::cout << foo.m_i << std::endl;
return 0;
}
выходы
2
Переписанный образец из этого ответа был бы тогда:
#include <thread>
#include <iostream>
class Wrapper {
public:
void member1() {
std::cout << "i am member1" << std::endl;
}
void member2(const char *arg1, unsigned arg2) {
std::cout << "i am member2 and my first arg is (" << arg1 << ") and second arg is (" << arg2 << ")" << std::endl;
}
std::thread member1Thread() {
return std::thread(&Wrapper::member1, this);
}
std::thread member2Thread(const char *arg1, unsigned arg2) {
return std::thread(&Wrapper::member2, this, arg1, arg2);
}
};
int main() {
Wrapper *w = new Wrapper();
std::thread tw1 = w->member1Thread();
tw1.join();
std::thread tw2 = w->member2Thread("hello", 100);
tw2.join();
return 0;
}
Вот полный пример
#include <thread>
#include <iostream>
class Wrapper {
public:
void member1() {
std::cout << "i am member1" << std::endl;
}
void member2(const char *arg1, unsigned arg2) {
std::cout << "i am member2 and my first arg is (" << arg1 << ") and second arg is (" << arg2 << ")" << std::endl;
}
std::thread member1Thread() {
return std::thread([=] { member1(); });
}
std::thread member2Thread(const char *arg1, unsigned arg2) {
return std::thread([=] { member2(arg1, arg2); });
}
};
int main(int argc, char **argv) {
Wrapper *w = new Wrapper();
std::thread tw1 = w->member1Thread();
std::thread tw2 = w->member2Thread("hello", 100);
tw1.join();
tw2.join();
return 0;
}
Компиляция с g ++ дает следующий результат
g++ -Wall -std=c++11 hello.cc -o hello -pthread
i am member1
i am member2 and my first arg is (hello) and second arg is (100)
Некоторые пользователи уже дали свой ответ и объяснили это очень хорошо.
Я хотел бы добавить еще несколько вещей, связанных с потоком.
#include<thread>
#include<Windows.h>
#include<iostream>
using namespace std;
class CB
{
public:
CB()
{
cout << "this=" << this << endl;
}
void operator()();
};
void CB::operator()()
{
cout << "this=" << this << endl;
for (int i = 0; i < 5; i++)
{
cout << "CB()=" << i << endl;
Sleep(1000);
}
}
void main()
{
CB obj; // please note the address of obj.
thread t(obj); // here obj will be passed by value
//i.e. thread will make it own local copy of it.
// we can confirm it by matching the address of
//object printed in the constructor
// and address of the obj printed in the function
t.join();
}
Другой способ достижения того же:
void main()
{
thread t((CB()));
t.join();
}
Но если вы хотите передать объект по ссылке, используйте синтаксис ниже:
void main()
{
CB obj;
//thread t(obj);
thread t(std::ref(obj));
t.join();
}
Поскольку вы используете C ++ 11, лямбда-выражение является хорошим и чистым решением.
class blub {
void test() {}
public:
std::thread spawn() {
return std::thread( [this] { this->test(); } );
}
};
, так как this->
может быть опущено, его можно сократить до:
std::thread( [this] { test(); } )
или просто
std::thread( [=] { test(); } )