Jan Kończak

Ta strona jest tylko do odczytu. Możesz wyświetlić źródła tej strony ale nie możesz ich zmienić.
===== Wątki w C++11 =====
Wraz ze standardem C++11 język C++ doczekał się obsługi wątków w bibliotece standardowej. \\
API do obsługi wątków jest identyczne z ''boost::thread'', z wyjątkiem obsługi przerywania wątków (''thread::interrupt()'').

Podsumowanie:
<code cpp>
#include <thread> // właściwy plik nagłówkowy
std::thread t; // tworzy pusty obiekt wątku.
t = thread(f); // tworzy nowy obiekt wątku w miejscu "t", niszcząc poprzedni obiekt wątku 
               // i uruchamia w nim "f"
// thread t2 = t; // kod NIEPOPRAWNY – wątków nie można kopiować
std::thread u(g, 1, 2, "z") // tworzy obiekt wątku (u), tworzy nowy wątek programu i uruchamia
                            // "g" z argumentami 1, 2 i "z"
t.join(); // czeka na zakończenie wątku
// thread * w = new thread(h); delete w; // niepoprawne – jeśli zmienna reprezentująca wątek 
                                         // ginie (''~thread::thread'') przed zakończeniem wątku,
                                         // to program jest abortowany
// Jeśli główny wątek (main) się zakończy, pozostałe są zabijane (zachowanie inne niż np. w Javie)
u.detach() // rozłącza wątek ze zmienną go reprezentującą. Można zmazać zmienną, wątek przeżyje.
std::thread(i).detach(); // tworzy nowy wątek bez deklaracji zmiennej która będzie go reprezentować.
</code>

<html><small></html>
W C++11 ustandaryzowano też zmienne lokalne dla wątku – w deklaracji zmiennej wystarczy dodać słowo kluczowe ''thread_local'', np:
<code cpp>
thread_local int tid = i.fetch_add(1);
</code>

Ponadto, dodano API do zamków, zmiennych warunkowych, zmiennych atomowych i futures
  * http://en.cppreference.com/w/cpp/atomic
  * http://en.cppreference.com/w/cpp/thread

<html></small></html>
===== <functional> w C++11 =====
<html><small><small></html>
Bardzo krótkie streszczenie:
<code cpp passingFuncs.cpp>
#include <thread>
#include <iostream>
#include <functional>
using namespace std;
using namespace std::placeholders;

void b(char c){ cout << c << endl;}

class C{
public:
	void operator()() {cout << 'C' << endl;}
	void operator()(char c) {cout << c << endl;}
} objC;

class E{
	const char * t_ = "ABCDEFGH";
public: 
	char f(int i){ cout << t_[i] << endl; return t_[i];}
	void g(){t_="G";}
} objE;

int main() {
	thread([]{cout << "A" << endl;}).join();        // lambda – http://en.cppreference.com/w/cpp/language/lambda
	thread(b, 'B').join();                          // "zwykła" funkcja
	thread(objC).join();                            // operator()
	thread(objC, 'D').join();                       // operator() z argumentami
	thread(bind(&E::f,objE,4)).join();              // funkcja na rzecz obiektu z ustalonym argumentem (currying)
	thread(bind(&E::f,objE,_1), 5).join();          // funkcja na rzecz obiektu z nieustalonym argumentem
	function<char(int)> funR(bind(&E::f,&objE,_1)); // funkcja na rzecz obiektu wołanego przez referencję
	function<char(int)> funC(bind(&E::f, objE,_1)); // funkcja na rzecz obiektu w stanie z chwili tworzenia funcC
	objE.g();                   // modyfikacja obiektu
	thread(funR, 0).join();     // wywołanie zmodyfikowanego obiektu - funcR zna obiekt przez referencję
	thread(funC, 7).join();     // wywołanie zmodyfikowanego obiektu - funcR zna obiekt przez wartość
	return 0;
}
</code>
<html></small></small></html>
Jan Kończak

Narzędzia użytkownika

Narzędzia witryny

Narzędzia strony
