Презентация на тему Многопоточные приложения

одновременно.

Одно ядро процессора может выполнять несколько задач, только переключаясь

между ними.

Один процесс выполняет одну задачу (например, взаимодействие с пользователем),

а другой – другую (например, вычисления).
Для увеличения производительности.



Увеличение числа параллельных процессов не всегда приводит к ускорению программы.

main(int argc,char * argv[]){
std::thread t(hello); // launch new thread
t.join();

//wait for finish of t

cin.get();
return 0;
}

одну ссылку на объект. Его нельзя копировать.
std::move – позволяет

перемещать содержимое unique_ptr;


void clearP(std::unique_ptr& ptr) {…}
std::unique_ptr p(new BigObject(4096));
std::thread t(clearP,std::move(p));

для данного приложения.

std::this_thread::get_id()
Возвращает идентификатор потока.

std::this_thread::sleep_for(std::chrono::milliseconds)
Позволяет усыпить поток на

время

функцию к элементам коллекции
template
Function for_each(InputIterator

first, InputIterator last, Function fn)
{
while (first!=last) {
fn (*first);
++first;
}
return fn; // or, since C++11: return move(fn);
}

std::mem_fn – делает из метода класса функцию, первый параметр которой объект класса

среде
При удалении элемента из связанного списка производится несколько операций:
-

удаление связи с предыдущим элементом
- удаление связи со следующим элементом
- удаление самого элемента списка

Во время выполнения этих операций к этими элементами обращаться из других потоков нельзя!

представлен в 4 формах в заголовочном файле :
mutex обеспечивает базовые

функции lock() и unlock() и не блокируемый метод try_lock()
recursive_mutex может войти «сам в себя»
timed_mutex в отличие от обычного мьютекса, имеет еще два метода: try_lock_for() и try_lock_until()
recursive_timed_mutex это комбинация timed_mutex и recursive_mutex

RAII-стиле с автоматической блокировкой и разблокировкой в рамках одного

блока. Эти классы:
lock_guard когда объект создан, он пытается получить мьютекс (вызывая lock()), а когда объект уничтожен, он автоматически освобождает мьютекс (вызывая unlock())
unique_lock в отличие от lock_guard, также поддерживает отложенную блокировку, временную блокировку, рекурсивную блокировку и использование условных переменных

пытаются получить доступ к нескольким ресурсам в разной последовательности.

устроить хранилище исключений, для того что бы их потом

обработать!

сначала выполнить std::unique_lock
condition_variable_any
более общая реализация, которая работает с любым

типом, который можно заблокировать
Должен быть хотя бы один поток, ожидающий, пока какое-то условие станет истинным. Ожидающий поток должен сначала выполнить unique_lock.
Должен быть хотя бы один поток, сигнализирующий о том, что условие стало истинным. Сигнал может быть послан с помощью notify_one(), при этом будет разблокирован один (любой) поток из ожидающих, или notify_all(), что разблокирует все ожидающие потоки.
В виду некоторых сложностей при создании пробуждающего условия, которое может быть предсказуемых в многопроцессорных системах, могут происходить ложные пробуждения (spurious wakeup). Это означает, что поток может быть пробужден, даже если никто не сигнализировал условной переменной. Поэтому необходимо еще проверять, верно ли условие пробуждение уже после то, как поток был пробужден.

анонимных функторов.
Например:
[](int _n) { cout

<< " ";}

Соответствует:
class MyLambda { public: void operator ()(int _x) const { cout << _x << " "; } };

лямбда-функции только один оператор return то тип значения можно

не указывать. Если несколько, то нужно явно указать.
[] (int i) -> double
{
if (i < 5)
return i + 1.0;
else if (i % 2 == 0)
return i / 2.0;
else
return i * i;
}

// без

захвата переменных из внешней области видимости
[=] // все переменные захватываются по значению
[&] // все переменные захватываются по ссылке
[this] // захват текущего класса
[x, y] // захват x и y по значению
[&x, &y] // захват x и y по ссылке
[in, &out] // захват in по значению, а out — по ссылке
[=, &out1, &out2] // захват всех переменных по значению, кроме out1 и out2,
// которые захватываются по ссылке
[&, x, &y] // захват всех переменных по ссылке, кроме x…

является полиморфной оберткой функций для общего использования. Объекты класса

std::function могут хранить, копировать и вызывать произвольные вызываемые объекты - функции, лямбда-выражения, выражения связывания и другие функциональный объекты. Говоря в общем, в любом месте, где необходимо использовать указатель на функцию для её отложенного вызова, или для создания функции обратного вызова, вместо него может быть использован std::function, который предоставляет пользователю большую гибкость в реализации.
Впервые данный класс появился в библиотеке Function в версии Boost 1.23.0[7]. После его дальнейшей разработки, он был включен в стандарт расширения C++ TR1 и окончательно утвержден в С++11.

Определение класса
template class function; // undefined
template class function;

ни один поток не может увидеть промежуточное состояние операции,

она либо выполняется, либо нет.
Например операция «++» не является атомарной:
int x = 0;
++x;
Транслируется в ассемблерный код, примерно так:
013C5595 mov eax,dword ptr [x]
013C5598 add eax,1
013C559B mov dword ptr [x],eax

char
std::atomic_uchar //unsigned char
std::atomic_int //int
std::atomic_uint //unsigned int

std::atomic_short //short
std::atomic_ushort //unsigned short
std::atomic_long //long
std::atomic_ulong //unsigned long
std::atomic_llong //long long
std::atomic_ullong //unsigned long long
std::atomic_char16_t //char16_t
std::atomic_char32_t //char32_t
std::atomic_wchar_t //wchar_t
std::atomic_address //void*

//Установить новое значение и вернуть предыдущее
compare_exchange_weak() // см. следующий

слайд
compare_exchange_strong() // compare_exchange_weak в цикле
fetch_add() //Аналог оператора ++
fetch_or() //Аналог оператора --
is_lock_free() //Возвращает true, если операции на данном типе неблокирующие

которые хранится в *this с Exp.
Если значения

равны то операция заменяет значение, которая хранится в *this на Val (*this=val) , с помощью операции read-modify-write.
Если значения не равны, то операция использует значение, которая хранится в *this, чтобы заменить Exp (exp=this).

node(data, head.load());
while (!head.compare_exchange_weak(
new_node->next,
new_node));
}