22. Hafta

/////////////////////////////////////////////////////// 1. Ders //////////////////////////////////////////////

int main()
{
using namespace std;

mt19937 eng{ 78234u }; //kopyalamadan kaçın, 5000 bytlık bir yer kaplar
mt19937 eng{sdt::chrono::steady_clock::now().time_since_epoch().count()}

}

----------------
aşağıda kötü yazılmış kod vardır

int main()
{
using namespace std;

random_device rd;

mt1993 eng{ rd() }; 
}

-------------

int main()
{
using namespace std;

mt1993 eng{ random_device{}() }; //böyle yap, scope leakage'dan kaçınmış olursun
}

-------------
bernolli dağılımı
random_device //bize non-determenistik bir sayı kaynağıda verebilir, ancak garanti değildir

int main()
{
using namespace std;

mt1993 eng{ random_device{}() };
bernolli_distribution dist{ 0.81 }; //bize 0.81 olasıklla true değeri dağıtmasını sağlarız
constexpr std::size_t n = 1'000'000u;
int cnt{};

for (size_t i{}; i < n; ++i) {
if (dist(eng)) {
++cnt;
}
}

cout << static_cast<double>(cnt) / n << "\n";
}

--------------
//bu şekilde kullanmanın avantajı sadece çağırdığımız zaman hayat gelicektir

std::mt19937& engine()
{
static std::mt199937 eng{std::random_device{}()};

return eng;
}

int main()
{
using namespace std;

uniform_int_distribution dist{0, 99};

cout << dist(engine()) << "\n";
cout << dist(engine()) << "\n";
cout << dist(engine()) << "\n";

}

-----------------

distruubiton nesnelerin param fonksiyonu vardır
2 farklı distrubiton nesnesinin aynı parametreleri kullanmasını sağlayabiliriz

int main()
{
using namespace std;

uniform_int_distribution dist1{0, 99};

auto prm = dist1.param();

uniform_int_distribution dist2{dist1.param()};
}

----------------

int main()
{
using namespace std;

discrete_distribution dist{1.2, 3.4, 5.6, 7.8};

dist.param() //bütün değerleri paketlemiş olucam
}

------------

int main()
{
using namespace std;

vector<int> ivec(100'000);
mt19937 eng;
uniform_int_distribution dist{4657, 8771};

generate(ivec.begin(), ivec.end(), [&eng, &dist] {return dist(eng);})
}

-------------

shuffle algoritması

int main()
{
using namespace std;

vector<string> svec{"bugra", "mete", "emre", "furkan","kutay", "mehmet","melike","cemal"};

for (int i = 0; i < 1000; ++i) {
shuffle(svec.begin(), svec.end(), mt19937{76265});
copy(svec.begin(), svec.end(), ostream_iterator<string>{cout, " "});
(void)getchar();
std::system("cls");
}
}

=================================================

concurrency
-----------

biraz giriş seviyesinde anlatılacak çok uzun bir konu

belirli işlemlerin belirli bir zaman diliminde birlikte yapılması demektir

mesela hem konuşuyorum hem yemek yiyorum burada birden fazla işşin zamanda çakışma olarak yapılmasıdır 

concurrency denildiğinde belli bir zaman diliminde birden fazla işin yapılmsı demek
parallizm denildiğinde birden fazla işin gerçekten aynı zaman diliminde birlikte yapılması demek (tamamen aynı anda)


concurrency : 1 expresso makinesi var 2 sıra var herkes oradan almak istiyor, paralellik yok
parallel : 2 expresso makinesi var 2 sıra var insanlar ikiye bölğnmüş bir şekilde kahve alıyor

konu çok geniş sabırlı olmak lazım

------------------

burada kritik nokta işletim sisteminin concurrency ilgili apileri
doğal olarak her şeyi yapabilir. ancak soyutlama yapmak üzere programlama dilinin
kütüphanesini kullandığımız zaman flexiblity azalır. her şeyi standart kütüphane ile yapamayız ancak bu fark zamanla azalır

-------------------

diyelim ki hem standarat kütüphaneyi kullanmak istiyorum standart kütüpahenin yeterli olmadığı yerlerde pthreas kütüphanesini kullanmak istyorum 
o standart kütüphanenin yetmediği yerde handle ile işletim sisteminin programlarını kullanabiliyoruz

------------------

thread : aynı uygulamada birden fazla bakış

------------------

neden kullanırız?

-mesela bir yerden dosya indirirken aynı zamanda başka işler yapmak isteyebiliriz, bunları bloke etmemek için

-işlemlerin daha hızlı yapabilmek için

!! her iş birden fazla thread kullanılırak daha hızlı yapılamaz çünkü bu işlemler maalitletlidir


------------------

c++ concurrency kütüphanesi 3 farklı seviyede araç sunuyor

- çok yüksek seviye (std::async)

- orta seviye (std::threads)

- alt seviye

--------------------------------

// bir thread nesnesi başka bir threadle ilişkili veya ilişkisis olabilir
1. thread nesnesine direk callable verebilirizi
2. thread nesnesine başka bir nesneyi taşuaybiliriz
3.thread copy delete edilmiştir, unique ptr gibi, move only type

çalıştırabilmek için bir thread nesnesini argüman vermemiz gerekiyor

#include <thread>

int main()
{
using namespace std;

thread th{/*callable*/} //callable, gerçek bir fonksiyon olabilir, function pointer olabilir, function object olabilir

}

---------------

int main()
{
using namespace std;

thread th1{[] {cout << "merhaba dunya";}}; //hepsi ayrı threadlerdie
thread th2{[] {cout << "merhaba dunya";}};
thread th3{[] {cout << "merhaba dunya";}};
thread th4{[] {cout << "merhaba dunya";}};
thread th5{[] {cout << "merhaba dunya";}};

}

-----------------

//thread nesnesi hem callable ister hemde callable'a gönderilecek argümanları ister

//bu fonksiyonu ayrı bir workload(iş yükü) olarak çalıştırıcak ayrı bir thread olarak çalıştırmak istesek
//thread nesnesini callable argüman olarak vermek gerekir
void func(int, int, int) 
{

}

int main()
{
using namespace std;

thread tx{func, 10, 20, 30};

// bu thread nesnesine 2 şey yapabiliriz
// ya join ya detach

th.join(); //akış burayı geçebilmesi için func fonksiyonunun kodunun bitmesi gerekiyor, iş yükü bitmemiş ise bitene kadar beklensin anlamına gelir
//statment, yani buraya gelebilmesi için func fonksiyonun kodunun bitmesi gerekir

tx.detach(); //ben bunun sorumluluğu ile ilgilenmiyorum arka planda bitene kadar çalışsın demektir
}

-------------------
thread nesnesi joineble durumdadır veya değildir

eğer bir iş yükü verilmişse ve başka bir yere taşıma yapılmış ise ya da join ya da detach fonksiyonlarından birisi çağrılmış ise

thread nesnesinin dtoru çağrıldıysa dtor'un çağrıldığı thread nesnesi eğer joineble durumuda değil ise terminate çağrılır

-------------------
//terminate çağrılır

void nec_terminate()
{
std::cout << "nec terminate cagrildi\n";
(void)getchar();
std::abort();
}

void func()
{
std::cout << "ben func isleviyim beni cagirdilar\n";
}

int main()
{
using namespace std;

set_termiante(nec_terminate);

{
thread tx{ func };

//tx.join(); //terminate çağrılmaz
}

std::cout << "main devam ediyor\n";
}

-------------------

joineble durumunda olduğunu öğrenmek için joineble fonksiyonu çağrılır

void nec_terminate()
{
std::cout << "nec terminate cagrildi\n";
(void)getchar();
std::abort();
}

void func()
{
std::cout << "ben func isleviyim beni cagirdilar\n";
}

int main()
{
using namespace std;

boolalpha(cout);

thread t;

cout << t.joinable() << "\n"; //false yazar, iş yüküne sahip değil
}

-------------

int main()
{
using namespace std;

boolalpha(cout);

thread t{ [] {} };

cout << t.joinable() << "\n"; //true

t.join();
cout << t.joinable() << "\n"; //false, artık join edilmiş
}

-------------

int main()
{
using namespace std;

boolalpha(cout);

thread t{ [] {} };

cout << t.joinable() << "\n"; //true

t.deatch();

cout << t.joinable() << "\n"; //false, 
}

--------------

void nec_terminate()
{
std::cout << "nec terminate cagrildi\n";
(void)getchar();
std::abort();
}

void func()
{
std::cout << "ben func isleviyim beni cagirdilar\n";
}

int main()
{
using namespace std;

boolalpha(cout);

thread t1{ [] {} };
thread t2{ move(t1) };

cout << t1.joinable() << "\n";  //false
cout << t2.joinable() << "\n";  //true

t2.join();

cout << t1.joinable() << "\n"; //false
cout << t2.joinable() << "\n"; //false
}

------------------
//joinable değilken join çağırırsak exception throw eder

void nec_terminate()
{
std::cout << "nec terminate cagrildi\n";
(void)getchar();
std::abort();
}

void func()
{
std::cout << "ben func isleviyim beni cagirdilar\n";
}

int main()
{
using namespace std;

thread tx{func};
tx.join();

try {
tx.join();
}
catch (const std::exception& ex) {
std::cout << "exception caught: " << ex.what() << '\n';
}
}

--------------------
mülakatlarda kesinlikle RAII idiomu sorarlar
-------------------
thread nesnesini kullanmak yerine thread nesnesini sarmalayan jtthread türünden sınıf oluştuurlur
burada RAII gerekir

void func()
{
throw std::runtime_error{ "hataaa"};
}

void foo() 
{
//code
}

void bar()
{
using namespace std;

thread t{ foo };

func();

t.join();
}

int main()
{
using namespace std;

try {
bar();
}
catch (const std::exception& ex) {
std::cout << "exception caught: " << ex.what() << '\n';
}

std::cout << "main devam ediyor\n";
}

--------------------

void func(char c)
{
for (int i = 0; i < 1000; ++i) {
std::cout.put(c);
}
}

int main()
{
for (char c = 'a'; c <= 'z'; ++c) {
func(c);
}
}

-------------------

func fonksiyonunu 26 ayrı thread'den çalıştırsaydım 

void func(char c)
{
for (int i = 0; i < 1000; ++i) {
std::cout.put(c);
}
}

int main()
{
using namespace std;

vector<thread> tvec(26);

char c = 'A';

for (auto& t : tvec) {
t = thread{func, c++} //pr value taşıma semantiği devreye girer hata olmaz
}

//join etmek lazım yoksa termiante çağrılır

for (auto& t : tvec) {
t.join();
}
}

--------------------
//aşağıdaki şekilde de olabilirdi

void func(char c)
{
for (int i = 0; i < 1000; ++i) {
std::cout.put(c);
}
}

int main()
{
using namespace std;

vector<thread> tvec;

for (char c = 'A'; c <= 'Z'; ++c) {
tvec.push_back(thread{func, c}); //push_back l value geçersek hata olur
//tvec.emplace_back(func, c); //bu şekilde olur
}

for (auto& t : tvec) {
t.join();
}
}

-----------------

void func(char c)
{
for (int i = 0; i < 1000; ++i) {
if (i == 456)
throw std::runtime_error{"hata ki ne hata aman allahım!"};
std::cout.put(c);
}
}

int main()
{
using namespace std;

try {
thread tx{ func, 'S' };
}
catch (const std::exception& ex) {
std::cout << "exception caught: " << ex.what() << '\n';
}
}

----------------

int foo(int x, int y)
{
//code
return x* y;
}

int main()
{
using namespace std;

thread tx{foo, 10, 56};

tx.join();

//Bu fonksiyonun geri dönüş degerini alma sansımız yok

//farklı parametreler kullanabiliriz ancak hepsi başka bir alt başlıktır
}

--------------

thread sınıfı move only bunun önemli durumları vardır

std::thread make_thread()
{
std::thread tx{ [] {
std::cout << "necati ders anlatiyor\n";
}};

return tx;
}

std::thread func(std::thread tx)
{
return tx;
}

int main()
{
auto t1 = make_thread();
auto t2 = move(t1);
t1 = func(move(t2));

t1.join();
}

----------------

herhangi bir callable verebiliriz derken burada kastedilen nedir

void func(int x)
{
std::cout << x << '\n';
}

int main()
{
using namespace std;

thread t1(func, 1);
thread t2([](int x) {cout << x << '\n';}, 2);

t1.join();
t2.join();

}

-------------------

class Funtor {
public:
void operator()(int x)const
{
std::cout << x;
}
};

struct Nec {
static void print(int x)
{
std::cout << x;
}

void display(int x)const
{
std::cout << x;
}
};

void func(int x)
{
std::cout << x << '\n';
}

int main()
{
using namespace std;

Nec mynec;
thread t1(func, 1);
thread t2([](int x) {cout << x << '\n';}, 2);
thread t3(Functor{}, 3);
thread t4(Nec::print, 4);
thread t5(&Nec::display, mynec, 5);

t1.join();
t2.join();
t3.join();
t4.join();
t5.join();

}

------------------
//void func(int&&r) //hata kalkar
void func(int& r)
{
r += 200;
}

int main()
{
int x = 67;

thread t{ func, x}; //r value olarak gönderiri l value kabul etmez

cout << "x = " << x << '\n'; //sentaxx hatası olur
}

---------------

void func(int& r)
{
r += 200;
}

int main()
{
using namespace std;

thread tx{func, ref(x)}; //legal

tx.join();

cout << "x = " << x << '\n';
}

---------------

void func(string&& r)
{
std::cout << r.size() << '\n';
}

int main()
{
using namespace std;

string name{"bugra serttas"}; //r value olarak göndeirir bu yüzden legal

thread tx{func, name};
}

-----------------

void func(string&& r)
{
std::cout << r.size() << '\n';
}

int main()
{
using namespace std;

string name{"bugra serttas"}; 

thread tx{func, name};

tx.join();

cout << name.size() << "\n";
}

------------------

void func(int&& r)
{
auto x = std::move(r);
std::cout << r.size() << '\n';
}

int main()
{
using namespace std;

string name{"bugra serttas"}; 

thread tx{func, name};

tx.join();

cout << name.size() << "\n";
}

//////////////////////////////////////////////////// 2. Ders /////////////////////////////////////////////

eğer l value olarak geçicek isek ve fonksiyonun parametresi l value ise kesinlikle l value geçmenin yolu referace wrapper kullanmak
bu kullanılmaz ise r value olarak kullanılır

class Myclass {
public:
Myclass() = default;
Myclass(const Myclass&)
{
std::cout << "copy ctor\n";
}

Myclass(Myclass&&)
{
std::cout << "move ctor\n";
}
};
//buraları dene teker teker
//void foo(Myclass&) //sentax hatası olur, r value expressin l value ya bağlanamaz
//void foo(const Myclass &) 
void foo(Myclass)
{

}

int main()
{
using namespace std;

Myclass m;
//const Myclass m;

thread t{foo ,m}; //önce dikey copy olur, copy ctor çağrılır

t.join();
}

---------------------

this_thread namespace'inin get_id isimli sınıfı vardır

get_id şu türden değer üretir

void func()
{

}

int main()
{
using namespace std;

thread t1{func};
auto x = t1.get_id();
cout << x << "\n";

t1.join();
}

-----------------
#include <syncstream>

void func()
{
osycstream{cout} << this_thread::get_id() <<'\n';
}

int main()
{
using namespace std;

thread t1{func}; 
cout << t1.get_id() << "\n"; //aynu çıkar

t1.join();
}

-----------------------

//birden fazla thread oluşturalım

void func()
{
osycstream{cout} << this_thread::get_id() <<'\n';
}

int main()
{
using namespace std;

func(); //buradaki func'da thread tarafından çalıştırıldı main'de bir thread'dir

vector<thread> tvec;

for (int i = 0; i < 10; ++i) {
tvec.emplace_back(func);
}

for (auto& t : tvec)
t.join();
}

---------------------

std::thread::id main_thread_id;

void func()
{
if (std::this_thread::get_id() == main_thread_id) {
std::cout << "main thread\n";
}
else {
std::cout << "ikicil thread\n";
}
}

int main()
{
using namespace std;

main_thread_id = std::this_thread::get_id();
func();
thread t{func};

t.join();
}

--------------------

thread t{foo, exp};

... for //bizden duration ister
... until //bizden timepoint ister

-------------------

using namespace std;

void func()
{
std::this_thread::sleep_for(2300ms); //thread'İ uyutur
std::cout << "tamer dundar\n";
}

int main()
{
using namespace std;

thread t{func};

t.join();
}

------------------

void func(char c, int val)
{
for (int i = 0; i < 1000; ++i) {
this_thread::sleep_for(milliseconds{ val });
cout.put(c);
}
}

int main()
{
using namespace std;

jthread t1{func, 'a', 100}; //fonksiyonu sarmalar ve dtor'u join çağırır
jthread t2{func, 'b', 300};
jthread t3{func, 'c', 500};
jthread t4{func, 'd', 799};
jthread t5{func, 'e', 950};

t.join();
}

-----------------
//öğretici bir kod cppreferance 'dan

auto now()
{
return std::chrono::steady_clock::now();
}

auto awake_time()
{
using std::chrono::operator""ms;
return now() + 2000ms;
}

int main()
{
std::cout << "Hello\n" << std::flush;
const auto start{now() };
std::this_thread::sleep_until(awake_time());
std::chrono::duration<double, std::milli> elapsed{now() - start};
std::cout << "Waited " << elapsed.count() << " ms\n";
}

-------------------

void func()
{
std::this_thread::yield(); //başka thread'lere öncelik ver anlamaında kullanılır   
}

------------------

int main()
{
using namespace std;

thread t{ [] {} };

auto handle = t.native_handle(); //işletim sistemlerinin api'lerine argüman olarak gönderilebilir

}

-------------------

int main()
{
using namespace std;

thread t{ [] {} };

cout << thread::hardware_concurrency() //gerçek anlamda paralel olarka kaç thread çalıştırabilir ona bakar

}

-------------------

//örneğin n tane thread oluşturmak istiyoruz hepsinin hardware tarafında paralel çalışmasını istiyoruz
//kaç tane thread oluşturabilirimin cevabını aşağıdaki şekilde alabiliriz

int main()
{
using namespace std;

vector<thread> tvec(thread::harware_concurerency());
}

---------------------

bir thread exception gönderirse o exception yakalama şansımız yok bu yüzden terminate çağrılır

void func(int x)
{
if (x % 2 == 0)
throw std::runtime_error{"even number error\n"};
}

void nec_terminate()
{
std::cout << "nec_terminate\n";
abort();
}

int main()
{
using namespace std;

try {
thread t{func, 12};
}
catch (const std::exception& ex) {
std::cout << "exception caught: " << ex.what() << '\n';
}
}

-----------------------

bunu yakalayan bir araç var

exception'ı exception_ptr türünden nesne ile sarmalayabiliyoruz

int main()
{
std::exception_ptr eptr;

current_exception() //exception_ptr döndürüyor, exception yakalanması durumunda exception_ptr nesnesi döndürür

retrow_exception() // bizden sarmalanan exception_ptr ister onu retrow eder
}

---------------------

void handle_saved_exception(std::exception_ptr eptr)
{
try{
if (eptr) {
std::rethrow_exception(eptr);
}
}
catch (const std::exception& ex) {
std::cout << "hata yakalandi: " << ex.what() << "\n";
}
}

int main()
{
std::exception_ptr eptr;

try {
std::string name{"furkan"};
auto c = name.at(45);
}
catch(...) {
eptr = std::current_exception();
}
handle_saved_exception(eptr);
}

-----------------

std::exception_ptr eptr{ nullptr };

void func(int x)
{
std::cout << "func cagrildi x = " << x << "\n";

if (x % 2 != 0) {
throw std::runtime_error{"hatali arguman " + std::to_string(x) };
}
}
catch(...) {
eptr = std::current_exception();
}

std::cout << "func islevi sona eriyor\n";
}

int main()
{
using namespace std;

thread tx{func, 121};

tx.join();

try {
if (eptr) {
rethrow_exception(eptr);
}
}
catch (const std::exception& ex) {
std::cout << "exception caught: " << ex.what() << '\n';
}
}

--------------------

std::vector<std::exception_ptr> g_epvec;
std::mutex mtx;
void f1()
{
void f1() {throw std::runtime_error{ "hata" };};
void f2() {throw std::invalid_argument{ "gecersiz arguman" };};
void f3() {throw std::out_of_range{ "aralik disi deger" };};
}

void tfunc1()
{
try {
f1();
}
catch (...) {
std::lock_guard guard{ mtx };
g_epvec.push_back(std::current_exception());
}
}


void tfunc2()
{
try {
f2();
}
catch (...) {
g_epvec.push_back(std::current_exception());
}
}

void tfunc3()
{
try {
f3();
}
catch (...) {
g_epvec.push_back(std::current_exception());
}
}

int main()
{
using namespace std;

thread t1{tfunc1};
thread t2{tfunc2};
thread t3{tfunc3};

t1.join();
t2.join();
t3.join();

for (const auto& ex : g_epvec) {
try {
rethrow_exception(ex);
}
catch (const std::exception& ex) {
std::cout << "exception caught: " << ex.what() << '\n';
}
}
}

---------------------

int main()
{
using namespace std;

exception_ptr eptr;

try {
throw std::runtime_error{"hata hata hata"};
}
catch(...) {
eptr = current_exception();
}

//yukarıdakiler ile aşağıdaki aynı anlamda

auto eptr = make_exception_ptr(std::runtime_error{ "hata hata hata"});
}

------------------------------------------------------

storage class

otomatik storage : 
static storage : gloabal, değişkenler
dynamic storage : 

//daha sonradan aşağıdaki'de eklendi

thread_local storage : her thread için ayrı bir değişken, thread çaşoştığı sürece o değişken hayatta kalıyor


------------

using namespace std;

void func(int x)
{
int ival = 10;

osyncstream{ cout } << "x = " << x << "\n";
osyncstream{ cout } << "ival = " << ival << "\n";
}

int main()
{
jthread t1{ func, 1 };
jthread t2{ func, 2 };
jthread t3{ func, 3 };
jthread t4{ func, 4 };
}

----------------

using namespace std;

void func(int &x)
{

}

int main()
{
int ival = 5;

jthread t1{func, ref(ival) };
jthread t2{func, ref(ival) };

}

----------------

static ömürlü değişkenler birden fazla thread tarafından kullanıldığında senkronizazyon mekanizması gerekiyor

otomatik ömürlü değişkenler için bir koruma mekanizması gerekmez

----------------

thread_local 

thread_local int x = 5; //hata olmaz çünkü thread_local keyword

-----------------

thread_local int x{ 0 };

void foo(const std::string& thread_name)
{
++x; //treat safe oldu, nir koruma gerektirmez

osyncstream{cout} << "thread" << name << " x = " << x << "\n";
}

int main()
{
jthread tx{foo, "tx"};
jthread ty{foo, "ty"};
jthread tm{foo, "tm"};
jthread tz{foo, "tz"};

osyncstream{cout} << "main thread x = " << x << "\n";

}

-----------------------------------

//puzzle sorusu neacti hocanın

thread_local int ival = 0;

void thread_func(int* p)
{
*p = 42;
std::cout << "*p = " << *p << '\n';
std::cout << "ival = " << ival << '\n'; //thread'İn ivali
}

int main()
{
std::cout << "ival = " << ival << '\n';
ival = 9;
std::cout << "ival = " << ival << '\n';
std::thread t(thread_func, &ival);
t.join();
std::cout << "ival = " << ival << '\n';
}

-------------------------

void foo()
{
int x = 0;                //automatic storage
static int y = 0;         //static storage
thread_local int z = 0;   //Thread_local 

++x;
++z;
++y;
}

---------------

std::mutex mtx;

void foo()
{
int x = 0;                //automatic storage
static int y = 0;         //static storage
thread_local int z = 0;   //Thread_local 

++x;
++z;
mtx.lock();
++y;
std::cout << "thread id : << id << " x(automatic) = " << x << '\n';
std::cout << "thread id : << id << " y(static) = " << x << '\n';
std::cout << "thread id : << id << " z(thread_local) = " << x << '\n';

mtx.unlock();
}

int main()
{
using namespace std;

jthread t1{foo, 1};
jthread t2{foo, 2};
jthread t3{foo, 3};
jthread t4{foo, 4};

}

----------------------
#include <syncstream>

thread_local std::string name {"cemal"};

void func(const std::string& surname)
{
name += surname;

std::osyncstream{std::cout} << name << " &name = " << &name << "\n";
}

int main()
{
using namespace std;

const char* const pa[] = {"akkan", "toprak", "kurtkaya", "ersoy", "canberk", "hasturk", "candan"};

vector<thread> tvec;

for (auto psurname : pa) {
tvec.emplace_back(func, psurname);
}

for (auto& t : tvec)
t.join();
}

------------------

class Myclass {
public:
Myclass(int)
{
std::osyncstream{std::cout} << "Myclass ctor x = " << x << " this = " << this << "\n";
}
~Myclass()
{
std::osyncstream{std::cout} << "Myclass destructor this = " << this << "\n";
}
};

void func(int x)
{
thread_local Myclass m{ x };
}

void foo(int x)
{
std::osyncstream{std::cout} << "foo(int) cagrildi x = " << x << "\n
func(x);
std::osyncstream{std::cout} << "foo(int) sona eriyor x = " << x << "\n
}

int main()
{
using namespace std;
{
jthread t1{foo, 1};
jthread t1{foo, 2};
jthread t1{foo, 3};
jthread t1{foo, 4};
}

std::cout << "main devam ediyor\n";
}

--------------------

thread_local değişken yerel değişken de olabilir.
böyle bir yerel değişkenin hayatl kapsamı sonunda bitmez.
threadin yürütülmesi sonunda hayatl sona erer .

-------------------

thread local std:mt19937 eng{454255u};

void foo()
{
std::uniform_int_distribution dist{10, 99};

for (int i = 0; i < 10; ++i) {
std::cout << dist(eng) << '\n';
}
}

int main()
{
std::thread t1{foo};
t1.join();
std::cout << '\n';
std::thread t2{ foo };
t2.join();
}

--------------------

class Myclass {
public:
Myclass()
{
std::osyncstream{std::cout} << "Myclass constructor this: " << this << '\n';
}

~Myclass()
{
std::osyncstream{std::cout} << "Myclass constructor this: " << this << '\n';
}
};

void foo()
{
std::osynctream{ std::cout } << "foo called\n";
thread_local Myclass m;
std::osynctream{ std::cout } << "foo ends\n";
}

void bar()
{
using namespace std::chrono_literals;
std:osyncstream{std::cout} << "bar called\n";
foo();
std::this_thread::sleep_for(3s);
std:osyncstream{std::cout} << "bar cends\n";
}

int main()
{
std::thread t{bar};
t.join();
}


-------------------------------------

paylaşımlı değişkenler

threadlerde paylaşımlı değişkenler büyük sorun yaratır

-aşağıdaki durumlar var ise sıkıntı olmaz

a) bütün değişkenlerimiz otomatik ömürlü
b) workload olarak çalıştırılacak fonksiyonlara referans semantiği ile çağrı yapmıyoruz
c) threadler thread_local değişkenkeri kullanıyr
d) dinamik ömürlü değişkenler paylaşımlı olarak kullanılmıyor
e) statik ömürlü değişkenler paylaşımlı olarak kullanılmıyor

paylaşımlı değişkenler tüm threadler tarafından sadece okuma amaçlı kullanılıyor

--------------------

std::atomic gcount = 0; // arayaa başka bir işlem giremez

void foo()
{
for (int i = 0; i < 100'000; ++i) {
++gcount;
}
}

void foo()
{
for (int i = 0; i < 100'000; ++i) {
++gcount;
}
}

void bar()
{
for (int i = 0; i < 100'000; ++i) {
---gcount;
}
}

int main()
{
using namespace std;
{
jthread t1{foo};
jthread t2{foo};
}

cout << "gcount = " << gcount << '\n';
}
}

=========================================

mutual exceplusion

birden fazla kişi var lavabo kullanılacak lavaboda olan kişi kilitlediği için içeri kimse giremez
ne zmaan lavabo kullanan kilidi açınca kullanılabilir durumda olabilir

acqurie : kilidi edinmeli
//critical section  
release : kilidi serbest bırakmak

------------------

int gcount = 0;

std::mutex mtx;

void func()
{
mtx.lock();
cout << this_thread::get_id() << "kilidi edindi\n"
++gcount;
cout << this_thread::get_id() << "kilidi serbest bıraktı\n"
mtx.unlock();
}

using namespace std;

int main()
{
thread t1{ func };
thread t2{ func };
thread t3{ func };
thread t4{ func };

t1.join();
t2.join();
t3.join();
t4.join();
}

------------------

int gcount = 0;

std::mutex mtx;

void func(int id)
{
mtx.lock();
cout << this_thread::get_id() << "kilidi edindi\n"
++gcount;
cout << this_thread::get_id() << "kilidi serbest bıraktı\n"
mtx.unlock();
}

using namespace std;

int main()
{
thread t1{ func, 1 };
thread t2{ func, 2 };
thread t3{ func, 3 };
thread t4{ func, 4 };

t1.join();
t2.join();
t3.join();
t4.join();
}


//////////////////////////////////////////////////// 3. Ders ////////////////////////////////////////

void foo(int &x)
{

}

using namespace std;

int main()
{
int x{ 35 };

jthread t1{foo, ref(x) };
jthread t2{foo, ref(x) };
jthread t3{foo, ref(x) };
}

-------------------

ortada birden fazla thread varsa tanımsız davranış olmaması için aşağıdaki koşullardan birisinin sağlanması gerekir
bu koşullardan birisi sağlanmıyorsa oluşan duruma data race deniyor, ub

a) const (immutuable)
b) yazma amaçlı bir tane bile thread yok
c) değişken atomic değil ise
---------

std::atomic x{0}; //Burası atomic olmasaydı ub olurdu

int main()
{
//Birden fazla thread kullanılıyor
}

-----------------------

bu durumlar multithread progrmalamının büyük problemlerinde  birisi

---------------------

bu durumların önüne geçebilmek için mutex kullanır

---------------------

mesela 

t1 => x = 59;  23.45.18 saatinde set edilmiş

t2 => x     ;  23.45.19 saatinde kullanılmış

bu t2'nin 59 kullanıcağı anlamına gelmez

bir işlemin daha önce yapılması daha sonra yapıalcak işlem tarafından kullanılacağı anlamına gelmiyor

-----------------------

sequneced-before relationship : aynı thread içinde oluşturulan sonucun aynı thread iiççinde değiştirilmesi

intra-thread : 

statement1;

statement2;

happends-before : zmaansal olarak önce olması demek değildir, A happens before B


----------------------
standart kütüphane birden fazla mutex sınıfı sunar

bunlardan en basici

std::mutex 'dir

diğer mutex sınıfları

MUTEX SINIFLARI
---------------
1- std::mutex
2- std::timed_mutex
3- std::recursive_mutex
4- std::recursive_timed_mutex
5- shared_mutex
6- shared_timed_mutex

aşağıya indikçe maaliyet artıyor en basic yetiyor ise onu kullan

-----------------------

std::mutex mtx;

int main()
{
mtx.lock; //mutex edinir
//critical area
//buradaki kod miktarını azaltmamız lazım
mtx.unlock; //mutex bırakır
}

//kritik bölgeyi ne kadar uzun tutarsak maaliyet o kadar artat

--------------------

std::mutex mtx;

int main()
{
while (mtx.try_lock()) { //true döndüğü sürece burası yürütülür

}
}

-----------------

std::mutex mtx;

int main()
{
mtx.native_handle()
}

------------------

mutex sınıfın non copy, non move

std::mutex mtx;

int main()
{
auto x = move(mtx); //Hata

}

----------------
//aşağıdaki gibi seneryolar ile karşılalabiliriz

using namespace std;

class Myclass {
public:
void foo() const
{
mtx.lock();
mtx.unlock();
}

private:
muatble std::mutex mtx;
};

-----------------

int cnt = 0;

void func()
{
for (int i = 0; i < 100'000; ++i) {
++cnt;
}
}

int main()
{
using namespace std;

vector<thread> tvec;

for (int i = 0; i < 10; ++i) {
tvec.emplace_back(func);
}

for (auto& t : tvec) {
t.join();
}

cout << "count = " << cnt << '\n';
}

-------------------

//aşağıdaki işlem mantıklı değildir olayı anlatmak içindir yoksa çok maaliyetli bir işlem

using namespace std;

std::mutex mtx;

int cnt = 0;

void func()
{
mtx.lock();
for (int i = 0; i < 100'000; ++i) {
++cnt;
mtx.unlokc();
}
}

int main()
{
using namespace std;

vector<thread> tvec;

for (int i = 0; i < 10; ++i) {
tvec.emplace_back(func);
}

for (auto& t : tvec) {
t.join();
}

cout << "count = " << cnt << '\n';
}

-------------------

using namespace std;

std::mutex mtx;
int cnt = 0;

void foo()
{
for (int i = 0; i < 10'000; ++i) {
++cnt;
}
}

void bar()
{
for (int i = 0; i < 10'000; ++i) {
--cnt;
}
}

int main()
{
//yukarıdaki kodlar ayrı fonksiyon diye senk. gerekmiyor diye düşenebilirsin ama senk. gerekiyor
std::thread t2{ foo };
std::thread t2{ bar };

t1.join();
t2.join();

std::cout << "x = " << x  << "\n";
}

------------------
//burada paylaşımlı değişken üzerinde bir korumaya gerek yoktur

std::mutex mtx1;
std::mutex mtx2;


void foo()
{
mtx1.lock();
for (int i = 0; i < 10'000; ++i) {
++cnt;
mtx1.unlock();
}
}

void bar()
{
mtx2.lock();
for (int i = 0; i < 10'000; ++i) {
--cnt;
mtx2.unlock();
}
}

int main()
{
//yukarıdaki kodlar ayrı fonksiyon diye senk. gerekmiyor diye düşenebilirsin ama senk. gerekiyor
std::thread t2{ foo };
std::thread t2{ bar };

t1.join();
t2.join();

std::cout << "x = " << x  << "\n";
}

------------------
//kendi senk. kendisi halleder

using namespace std;

void func(std::string str)
{
for (int i = 0; i < 1000; ++i) {
cout << str << "\n";
}
}

int main()
{
jthread t1{func, "emracan suster"};
jthread t2{func, "tamer dundar"};
jthread t3{func, "furkanmert"};
}

----------------------
//böyle durumlarda deaclock denir kilit bırakılmıyor
//bu durumları engellemk için raıı idiomu kullanılır

using namespace std;

std::mutex mtx;

void foo()
{
throw std::runtime_error{ "error from foo" };
}

void func()
{
mtx.lock();
try {
foo();
mtx.unlock();
}
catch(const std::exception& ex) {
mtx.unlock();
}
}

----------------
raıı

void foo()
{
throw std::runtime_error{"error from foo"};
}

void func()
{
//lock_guard lg(mtx);
try {
foo();

mtx.unlock();
}
catch (const std::exception& ex) {

}
}

--------------------

std::mutex içinde onu kilitleyen ve dtor çağrıldığında onu unlcok eden raıı sınıfı dediğimiz sınıflar var

MUTEX SARMALAYAN RAII SINIFLARI
-------------------------------
1- lock_guard
2- unique_lock
3- scoped_lock
4- shared_lock

--------------------

using namespace std;

std::mutex mtx;

void foo()
{
lock_guard<mutex> lock{ mtx };
//statements
//statements
//statements
}

void func()
{
lock_guard<timed_mutex> lg(mtx); //bu şekilde yazmaya gerek yok
lock_guard lg(mtx);
try{
foo();

mtx.unlock();
}
}

-------------------

using namespace std;

std::timed_mutex mtx;

void func()
{
lock_guard lg(mtx);

auto x = move(lg);
}

-------------------

using namespace std;

std::mutex mtx;

void func()
{
mtx.lock();

lock_guard lg(mtx); //burada tekrar kilitlemiş oluruz sakıncalı bir durum
lock_guard lg(mtx, adopt_lock); //burada zaten kilitlenmiş olduğunu biliyor
}

--------------------

using namespace std;

void func()
{
std::timed_mutex mtx;

if (mtx.try_lock_for(50ms)) { //50ms boyunca lock eder

}

}

---------------------

using namespace std;
using namespace chrono;

int cnt{};

void try_increment()
{
for (int i = 0; i < 100'000; ++i) {
if (mtx.try_lock()) {
++cnt;
mtx.unlock();
}
}
}

int main()
{
using namespace std;

vector<thread> tvec;

for (int i = 0; i < 10; ++i) {
tvec.emplace_back(tyr_incerement);
}

for (auto& t : tvec)
t.join();

cout << "x = " << x << '\n';

}

---------------------


using namespace std;
using namespace chrono;

int cnt{};
std::timed_mutex mtx;

void try_increment()
{
for (int i = 0; i < 100'000; ++i) {
if (mtx.try_lock(1us)) {
++cnt;
mtx.unlock();
}
}
}

int main()
{
using namespace std;

vector<thread> tvec;

for (int i = 0; i < 10; ++i) {
tvec.emplace_back(tyr_incerement);
}

for (auto& t : tvec)
t.join();

cout << "x = " << x << '\n';

}

-------------------

std::mutex mtx;

void foo()
{
std::cout << "foo is trying to lock the mutex\n";
mtx.lock();
std::cout << "foo has locked the mutex\n";
std::this_thread::sleep_for(600ms);
std::cout << "foo has unlocked the mutex\n";
mtx.unlock();
}

void bar()
{
std::this_thread::sleep_for(100ms);
std::cout << "bar is trying to lock the mutex\n";
while (!mtx.tyr_lock()) { 
std::cout << "bar could not lock the mutex\n";
std::this_thread::sleep_for(100ms);
}
std::cout << "bar has locked the mutex\n"; //buraktığı zaman ancak lock eder
mtx.unlock(); 
}

int main()
{
std::jthread t1{ foo };
std::jthread t2{ bar };
}

----------------------

class List {

private:
std::mutex mtx; //her list sınıfınn ayrı mutex'i var
static std::mutex mtx; //her list sınıfınnı aynı mutexi olur
};

---------------------
//mülakatlarda aşağıdaki gibi kod yazıp thread safe ile ilgili bir problem var mı soruus soruyorlar

class List {
public:
void push_back(int x)
{
std::lock_guard lg{mtx};
mlist.push_back(x);
} //burada unlock olur
void print()const
{
std::lock_guard lg{ mtx };
for (const auto val : mlist)
{
std::cout << val << ' ';
}
std::cout << '\n';
}
private:
mutable std::mutex mtx;
std::list<int> mlist;
};

void func(List& list, int x)
{
for (int i = 0; i < 10; ++i) {
list.push_back();
}
}

-----------------------

deadlock : bir threadin ilerleyememesi

-----------------------

tipik bir deadlock kodu

using namespace std;

mutex a_mtx;
mutex b_mtx;

void foo()
{
std::osyncstream{cout} << this_thread::get_id() << " is trying to lock a_mtx\n";
a_mtx.lock();
std::osyncstream{cout} << this_thread::get_id() << " has locked a_mtx\";
td::sleep_for(600ms);
std::osyncstream{cout} << this_thread::get_id() << " is trying to lock b_mtx\n";
b_mtx.lock();
std::osyncstream{cout} << this_thread::get_id() << " has locked b_mtx\";
a_mtx.unlock();
std::osyncstream{cout} << this_thread::get_id() << " has unlock a_mtx\n";
b_mtx.unlock();
osyncstream{cout} << this_thread::get_id() << " has unlock b_mtx\n";
}

void bar()
{
std::osyncstream{cout} << this_thread::get_id() << " is trying to lock b_mtx\n";
b_mtx.lock();
std::osyncstream{cout} << this_thread::get_id() << " has locked b_mtx\";
td::sleep_for(600ms);
std::osyncstream{cout} << this_thread::get_id() << " is trying to lock b_mtx\n";
a_mtx.lock();
std::osyncstream{cout} << this_thread::get_id() << " has locked a_mtx\";
b_mtx.unlock();
std::osyncstream{cout} << this_thread::get_id() << " has unlock b_mtx\n";
a_mtx.unlock();
osyncstream{cout} << this_thread::get_id() << " has unlock a_mtx\n";
}

int main()
{
jthread t2{foo};
jthread t2{bar};

}

//zaten kilitli dosyalar tekrar kilitlenmeye çalışılıyor, deadlock oluşur

----------------

//bunlarla baş etmenin yolları var

std::lock()

using namespace std;

mutex a_mtx;
mutex b_mtx;

void foo()
{
std::lock(a_mtx, b_mtx);
}

int main()
{
std::lock(a_mtx, b_mtx);
}

-----------------

mutex m;
timed_mutex tm;
recursive_mutex rm;

void foo()
{
scoped_lock<std::mutex, std::timed_mutex, std::recursive_mutex>
}

-------------------

class Myclass {
public:
void foo()
{
mtx.lock();
bar();
mtx.unlock();
}

void bar()
{
mtx.lock();
 //tanımsız davranış olur
mtx.unlock();
}

private:
mutable std::mutex mtx;
};

int main()
{
using namespace std;

Myclass m;

thread t{ &Myclass::foo, ref(m)};

t.join();
}

--------------------

recursive mutex yaparsak doğru çalışır

class Myclass {
public:
void foo()
{
mtx.lock();
bar();
mtx.unlock();
}

void bar()
{
mtx.lock();
mtx.unlock();
}

private:
mutable std:recursive_mutex mtx;
};

int main()
{
using namespace std;

Myclass m;

thread t{ &Myclass::foo, ref(m)};

t.join();
}

--------------------

std::mutex mtx;
//std::recursive_mutex mtx; //ub kalkar
int factoriyal(int x) //tanımsız davranış
{
lock_guard lg{ mtx };

return x < 2 ? 1 : x * factorial(x - 1);
}

int main()
{
thread tx{factorial, 5};

tx.join();
}