Haftal\u0131k C++ 8- std::thread (II)<\/a><\/span><\/strong><\/p>\n Haftal\u0131k C++ 10- std::thread (III)<\/a><\/span><\/strong><\/p>\n Asl\u0131nda, ilk etapta, senkronizasyon yap\u0131lar\u0131ndan da bahsetmeyi planl\u0131yordum fakat daha sonra bu yaz\u0131y\u0131 sadece yard\u0131mc\u0131 yap\u0131larak ay\u0131r\u0131p, senkronizasyon yap\u0131lar\u0131 i\u00e7in ayr\u0131 bir yaz\u0131 yazmaya karar verdim. \u00d6b\u00fcr t\u00fcrl\u00fc, yaz\u0131y\u0131 takip etmek ve b\u00fct\u00fcnl\u00fc\u011f\u00fc korumak ger\u00e7ekten zor olacakt\u0131. Bu yaz\u0131mda sizlere aktaraca\u011f\u0131m konular ise: async, futures, promises, packaged_tasks<\/em>\u00a0ve son olarak atomics <\/em>veri yap\u0131lar\u0131. Evet hadi o zaman, ba\u015flayal\u0131m.<\/p>\n async ‘<<\/em>future>‘\u00a0<\/em>k\u00fct\u00fcphanesi taraf\u0131ndan farkl\u0131 prototipleri sunulan, ba\u011f\u0131ms\u0131z \u015fablon bir fonksiyondur (template function). Bu fonksiyonlar, parametre olarak ge\u00e7irilen fonksiyonlar\u0131 asenkron olarak ko\u015fturup (bu genelde ayr\u0131 bir thread olu\u015fturularak ve ko\u015fturulmas\u0131 ile sa\u011flan\u0131r, ama geli\u015ftirici bundan soyutlan\u0131r), sonucu ve ko\u015fum durumunu std::future<\/em> nesnesi (birazdan a\u00e7\u0131klayaca\u011f\u0131m) olarak d\u00f6nerler. Asl\u0131nda g\u00f6rebilece\u011finiz \u00fczere, bu yap\u0131, basit thread kullan\u0131m ihtiya\u00e7lar\u0131n\u0131z\u0131 gidermek i\u00e7in geli\u015ftirilmi\u015f bir \u00fcst seviye yap\u0131 olarak de\u011ferlendirilebilir. Di\u011fer bir deyi\u015fle, bu metot kullanarak yapaca\u011f\u0131n\u0131z herhangi bir i\u015fi Thread k\u00fct\u00fcphanesinin di\u011fer yap\u0131lar\u0131n\u0131 da kullanarak yapabilirsiniz.<\/p>\n Tahmin edebilece\u011finiz \u00fczere, bu metotlara, fonksiyon, fonksiyon i\u015faret\u00e7isi, fonksiyon nesnesi ve lambda fonksiyonlar\u0131n\u0131, ihtiya\u00e7 duyduklar\u0131 parametreleri ile birlikte ge\u00e7irebilirsiniz. Bu parametreleri de async()<\/em> metotlar\u0131na parametre olarak ge\u00e7irebilirsiniz. \u0130lgili metodun dok\u00fcmantasyonun verilen a\u015fa\u011f\u0131daki \u00f6rnek kod, asl\u0131nda bu kullan\u0131mlar\u0131 g\u00fczel bir \u015fekilde \u00f6zetliyor:<\/p>\n Bu fonksiyon ve parametreler yan\u0131nda async metodu, bir de \u00e7al\u0131\u015ft\u0131rma politikas\u0131 denile ve \u00fc\u00e7 farkl\u0131 de\u011fer alan bir parametre de kabul etmektedir:<\/p>\n async()<\/em> kullan\u0131m\u0131n\u0131 daha iyi anlaman\u0131za yard\u0131mc\u0131 olaca\u011f\u0131n\u0131 d\u00fc\u015f\u00fcnd\u00fc\u011f\u00fcm bir \u00f6rnek kod daha ekliyorum (al\u0131nt\u0131lad\u0131\u011f\u0131m kayna\u011fa da referanslardan ula\u015fabilirsiniz):<\/p>\n Bu arada, yukar\u0131da verdi\u011fim \u00f6rnekte dikkat etmenizi istedi\u011fim nokta std::future<\/em> nesnesine ili\u015fkin get() API’sinin \u00e7a\u011fr\u0131ld\u0131\u011f\u0131 zaman mevcut thread’i verilen i\u015f tamamlan\u0131ncaya kadar bloklamas\u0131d\u0131r. Bunun yan\u0131nda, std::async()<\/em> metodundan d\u00f6n\u00fclen std::future<\/em> nesnesinin y\u0131k\u0131c\u0131s\u0131 \u00e7a\u011fr\u0131ld\u0131\u011f\u0131nda da, benzer \u015fekilde mevcut thread bloklan\u0131r. A\u015fa\u011f\u0131da buna ili\u015fkin bir kullan\u0131m g\u00f6sterdim:<\/p>\n Bunun ile ilgili daha detayl\u0131 bilgilere Scott Meyers’in sayfas\u0131ndan ula\u015fabilirsiniz:\u00a0Scott’s blog post<\/span><\/strong><\/a>.<\/p>\n \u015eimdi, std::future’a bakma zaman\u0131.<\/p>\n C++11 thread k\u00fct\u00fcphanesi ile gelen bir di\u011fer yap\u0131 da std::future<\/em> s\u0131n\u0131f\u0131d\u0131r. Bunun kullanmak i\u00e7in\u00a0‘<future>’ ba\u015fl\u0131k dosyas\u0131n\u0131 kaynak kodunuza eklemeniz gerekiyor. Bu yap\u0131, yukar\u0131da g\u00f6rd\u00fc\u011f\u00fcn\u00fcz gibi async<\/em>() metodu yan\u0131nda std::packaged_task<\/em> ve std::promise<\/em> yap\u0131lar\u0131 ile de kullan\u0131lmaktad\u0131r. Peki ne yapar bu s\u0131n\u0131f? Bu s\u0131n\u0131f\u0131n temel i\u015flevi, k\u0131saca async<\/em>() metodu gibi thread ko\u015fumlar\u0131nda, ilgili de\u011ferlerin d\u00f6n\u00fclmesine sa\u011flamakt\u0131r.<\/p>\n Geleneksel olarak, thread’ler aras\u0131nda veri payla\u015f\u0131m\u0131n\u0131 ger\u00e7ekle\u015ftirmek i\u00e7in, mutex ve benzeri thread senkronizasyon yap\u0131lar\u0131n\u0131 kullanman\u0131z gerekmektedir. Dahas\u0131, ger\u00e7ekle\u015ftirilen bu i\u015flem sonras\u0131nda, \u00e7a\u011f\u0131ran s\u0131n\u0131f\u0131 haberdar etmek i\u00e7in de\u00a0 std::conditional_variable<\/em> tarz\u0131 yap\u0131lar\u0131 da kullanman\u0131z gerekebiliyor. std::future<\/em>, bu tarz temel ihtiya\u00e7lar\u0131 gidermek i\u00e7in sunulan bir s\u0131n\u0131f. Bu s\u0131n\u0131f, ca\u011fr\u0131lan thread taraf\u0131ndan sa\u011flanacak olan veriyi tutar ve ilgili \u00e7a\u011f\u0131ran buna eri\u015fmesi i\u00e7in gerekli olan alt yap\u0131lar\u0131 geli\u015ftiriciye sunmadan kotar\u0131r. Ne zamanki, \u00e7a\u011f\u0131ran s\u0131n\u0131f std::future<\/em> nesnesine ili\u015fkin get<\/em>() API’sini \u00e7a\u011f\u0131r\u0131r, o zaman ilgili i\u015f bitene kadar bu thread bloklan\u0131r ve verilen i\u015f bitince de ilgili de\u011fer d\u00f6n\u00fcl\u00fcr.<\/p>\n Bu s\u0131n\u0131fa benzer \u015fekilde, std::promise<\/em> s\u0131n\u0131f\u0131 da asl\u0131nda std::future<\/em> ile d\u00f6n\u00fclecek bir de\u011fer i\u00e7in s\u00f6z olarak kabul edilebilir. Bir di\u011fer deyi\u015fle, her bir std::promise<\/em> nesnesi ile ilintili bir std::future<\/em> nesnesi bulunur ve bu ilgili de\u011feri \u00e7a\u011f\u0131rana sa\u011flar. Peki std::promise<\/em>‘in buradaki kullan\u0131m\u0131 nedir? std::promise<\/em> nesnesi, std::future<\/em> nesnesi ile birlikte payla\u015ft\u0131\u011f\u0131 verinin, ilgili thread i\u00e7erisinde atanmas\u0131 i\u00e7in gerekli aray\u00fcz sunar. Bu kadar a\u00e7\u0131klaman\u0131n biraz kafa kar\u0131\u015ft\u0131r\u0131c\u0131 olabilece\u011finin fark\u0131nday\u0131m, yine referanslarda verdi\u011fim bir kaynakta buraya koydu\u011fum a\u015fa\u011f\u0131daki fig\u00fcr, bu iki nesne aras\u0131ndaki ili\u015fki ve kullan\u0131mlar\u0131n\u0131 \u00e7ok g\u00fczel \u00f6zetliyor:<\/p>\n Burada std::promise<\/em> nesnesi asl\u0131nda arkada iki thread aras\u0131nda payla\u015f\u0131lacak olan veriyi ifade\/temsil ediyor. std::future<\/em> nesnesi ise bu std::promise<\/em> nesnesi \u00fczerinden d\u00f6n\u00fclecek de\u011feri temsil ediyor. Genel kullan\u0131m\u0131 bakt\u0131\u011f\u0131m\u0131z zaman, ilgili threadi olu\u015fturan, \u00f6ncelikle bir std::promise<\/em> nesnesi olu\u015fturuyor ve buna ilintilendirilmi\u015f bir ya da daha fazla std::future<\/em> nesnesini ediniyor. Daha sonra std::promise<\/em> nesnesini, olu\u015fturaca\u011f\u0131 yeni thread’e ge\u00e7iriyor ve yeni thread bu nesne \u00fczerinden payla\u015f\u0131lacak olan veriyi at\u0131yor ya da hata durumunu iletiyor. Bu a\u015famada, std::future<\/em> nesneleri \u00fczerinden ilgili d\u00f6n\u00fc\u015f de\u011ferinin atan\u0131p\/atanmad\u0131\u011f\u0131 ya da bir hata olup olmad\u0131\u011f\u0131 sorgulanabilmektedir. A\u015fa\u011f\u0131da bu iki s\u0131n\u0131f\u0131n ili\u015fkisini g\u00f6steren kod par\u00e7as\u0131n\u0131 g\u00f6rebilirsiniz:<\/p>\n E\u011fer\u00fc std::promise nesnesi, ilgili d\u00f6n\u00fc\u015f de\u011feri \u00e7a\u011fr\u0131lmadan silinirse ve de olu\u015fturan thread, std::future nesnesi \u00fczerinden get() API’sini \u00e7a\u011f\u0131r\u0131r ise, hata durumu olu\u015ftur. Bunun yan\u0131nda bir di\u011fer kullan\u0131m ile birlikte, birden fazla std::promise nesnesini olu\u015fturulan thread’lere ge\u00e7irerek, \u00e7a\u011f\u0131ran s\u0131n\u0131f bunlara ili\u015fkin std::future nesnelerinden ayr\u0131 ayr\u0131 de\u011ferler elde edilebilir.<\/p>\n Bu iki yap\u0131ya ili\u015fkin g\u00fczel bir a\u00e7\u0131klama da Rainer Grim taraf\u0131ndan \u015fu yaz\u0131da<\/a>\u00a0<\/span><\/strong>verilmi\u015f durumda. \u00d6zetleyecek olursak:<\/p>\n std::promise nesnesi:<\/p>\n std::future nesnesi:<\/p>\n Bu iki yap\u0131n\u0131n kullan\u0131m\u0131na ili\u015fkin bir di\u011fer \u00f6rnek koda g\u00f6z atal\u0131m:<\/p>\n std::future s\u0131n\u0131f\u0131na benzer bir di\u011fer s\u0131n\u0131f da std::shared_future s\u0131n\u0131f\u0131. Bu s\u0131n\u0131f\u0131n i\u015flevini galiba en iyi dok\u00fcmantasyonundaki (std::shared_future API dok\u00fcmantasyonu<\/a>)\u00a0<\/span><\/strong>a\u015fa\u011f\u0131daki tan\u0131m \u00f6zetliyor:<\/p>\n std :: shared_future s\u0131n\u0131f \u015fablonu, ger\u00e7ekle\u015ftirilecek olan bir i\u015flemin d\u00f6n\u00fc\u015f de\u011ferine birden fazla thread’in eri\u015fmesine ve ilgili de\u011ferin i\u00e7in bekletilmesine olanak sa\u011flar. std::future’dan farkl\u0131 olarak (sadece ta\u015f\u0131narak aktar\u0131labilir), bu nesneler kopyalanabilir ve her bir kopya ayn\u0131 ortak de\u011fere eri\u015firler. Yaln\u0131zca hareketli olan std :: future’nin aksine (bu nedenle yaln\u0131zca bir \u00f6rnek, herhangi bir zaman uyumsuz sonuca i\u015faret edebilir), std :: shared_future kopyalanabilir ve birden \u00e7ok payla\u015f\u0131lan gelecek nesnesi ayn\u0131 payla\u015f\u0131lan duruma ba\u015fvurabilir. Asl\u0131nda, bir shared_future, std :: condition_variable :: notify_all ()’a benzer \u015fekilde, ayn\u0131 anda birden fazla i\u015f par\u00e7ac\u0131\u011f\u0131na sinyal vermek i\u00e7in kullan\u0131labilir. Bu s\u0131n\u0131f, bir bak\u0131ma, birden fazla thread’i, std::condition_variable::notify_all() API’si gibi, haberdar etmek i\u00e7in kullan\u0131labilir.<\/p>\n Hemen nas\u0131l kullan\u0131ld\u0131\u011f\u0131na \u00f6rnek bir kod \u00fczerinden bakal\u0131m:<\/p>\n std::future, promise ve async ile ilintili bir di\u011fer s\u0131n\u0131f da\u00a0std::packaged_task<> s\u0131n\u0131f\u0131. Bu s\u0131n\u0131f, asenkron olarak \u00e7a\u011fr\u0131labilecek olan i\u015flevleri temsil eder, async() metodu ise direk ba\u015flat\u0131yordu hat\u0131rlarsan\u0131z (birazdan sekme sekme farklar\u0131 da ifade edece\u011fim). \u0130lgili i\u015flevlerin d\u00f6n\u00fc\u015f de\u011ferleri veya hata durumlar\u0131 yine ayn\u0131 nesne i\u00e7erisinde tutulur ve std::future<\/a><\/span><\/strong><\/span>\u00a0nesneleri \u00fczerinden eri\u015filir. Bu s\u0131n\u0131f a\u015fa\u011f\u0131dakileri kapsar:<\/p>\n Burada ilgili std::packaged_task nesnesinden elde edece\u011finiz std::future nesnesi ile ilgili i\u015flevden d\u00f6n\u00fclen de\u011fere ve hata durumuna bakabilirsiniz. A\u015fa\u011f\u0131da bu s\u0131n\u0131f\u0131n kullan\u0131m\u0131na ili\u015fkin \u00f6rnek bir kod bulabilirsiniz:<\/p>\n Yukar\u0131daki \u00f6rnekten de g\u00f6rece\u011finiz \u00fczere std::packaged_task nesnelerini kopyalayamazs\u0131n\u0131z, sadece ta\u015f\u0131yabilirsiniz. Bu sebeple, ilgili nesne, threadlere ge\u00e7irilmeden \u00f6nce genelde, std::future nesnesi tutulur (thread e ilgili std::packaged_task nesnesi ta\u015f\u0131naca\u011f\u0131 i\u00e7in elimizde bir kopya kalmaz).<\/p>\n Gelelim sadede, packaged_task ile async metodu aras\u0131ndaki fark ne peki? G\u00fczel bir soru? Bu farklar\u0131 k\u0131saca a\u015fa\u011f\u0131daki gibi \u00f6zetleyebiliriz:<\/p>\n Evet sstd::packaged_task konusu da bu kadar.<\/p>\n Bir \u00f6nceki yaz\u0131m\u0131 okuduysan\u0131z, multithreaded programlama da dikkat etmeniz gereken en \u00f6nemli konulardan birisi de thread’ler aras\u0131 payla\u015f\u0131lan verilerin korunmas\u0131d\u0131r. Bu anlamda thread k\u00fct\u00fcphanesinde, bir sonraki thread yaz\u0131mda da anlataca\u011f\u0131m \u00fczere, bir \u00e7ok yap\u0131 bulunmakta. Bu yaz\u0131mda ise thread k\u00fct\u00fcphanesi ile gelen ve basit veriler i\u00e7in bu tarz yap\u0131lardan bizi kurtaran bir yap\u0131dan bahsedece\u011fim. Bunlar: Atomik Tiplerdir<\/em>. \u0130lgili referans (std::atomic library referans sayfas\u0131<\/a>)<\/span><\/strong> sayfas\u0131nda da ifade edildi\u011fi \u00fczere bu yap\u0131lar, i\u00e7erisinde bar\u0131nd\u0131rd\u0131\u011f\u0131 veri tiplerine, bir \u00e7ok thread’in eri\u015fimine herhangi bir “data race” ya da problem olmadan, senkronize bir \u015fekilde eri\u015fimini sa\u011flarlar. Daha fazla detaya girmeden \u00f6nce hemen \u00f6rnek bir kod \u00fczerinden ge\u00e7elim:<\/p>\n Yukar\u0131daki \u00f6rnek kodun \u00fczerinden ge\u00e7er ge\u00e7mez, bu s\u0131n\u0131f\u0131n multithreaded ortamlar i\u00e7in uygun ve g\u00fcvenli olmad\u0131\u011f\u0131n\u0131 anlam\u0131\u015fs\u0131n\u0131zd\u0131r. Normal \u015fartlarda std::mutex ve benzeri yap\u0131lar\u0131 kullanarak bunu g\u00fcvenli hale getirebiliriz. \u015eimdi, bu kodu atomik tipleri kullanarak nas\u0131l g\u00fcvenli hale getirebilece\u011fimize bakal\u0131m.<\/p>\n \u00d6ncelikli olarak atomik tipler de, yukar\u0131da bahsetti\u011fim s\u0131n\u0131flar gibi \u015fablon bir s\u0131n\u0131f (template class). Kullanabilmek i\u00e7in\u00a0 Bu s\u0131n\u0131f taraf\u0131ndan sunulan API’ler\u00a0store<\/em>() ve\u00a0load<\/em>() metotlar\u0131d\u0131r. Bunlar ilgili verilere eri\u015fim ve g\u00fcncelleme i\u00e7in kullanabilirler. Ayn\u0131 zaman atama operat\u00f6r\u00fc de kullan\u0131labilir. Bir di\u011fer kullan\u0131\u015fl\u0131 API ise exchange()’dir<\/em>, bu API verilen parametreyi ilgili atomik de\u011fi\u015fkene atar ve \u00f6nceki de\u011feri d\u00f6ner. Son olarak kullanabilece\u011finiz iki API daha var. Bunlar compare_exchange_weak()<\/em>\u00a0ve\u00a0compare_exchance_strong(). <\/em>Bunlar ise de\u011fi\u015fkene veri atama i\u015fini sadece verilen de\u011fer mevcut de\u011fere e\u015fit ise yapar. Son \u00fc\u00e7 API, genelde “lock-free” algoritmalar ve veri yap\u0131lar\u0131nda s\u0131kl\u0131k ile kullan\u0131l\u0131r (umar\u0131m bu konu ile ilgili de bir yaz\u0131 sizler ile payla\u015faca\u011f\u0131m). Ayr\u0131ca b\u00fct\u00fcn tam say\u0131 tipleri i\u00e7in ++, –, fetch_add, fetch_sub operat\u00f6r ve API’leri de tan\u0131ml\u0131d\u0131r (tam liste i\u00e7in https:\/\/en.cppreference.com\/w\/cpp\/atomic\/atomic’<\/a><\/strong><\/span>e ba\u015fvurabilirsiniz).<\/p>\n \u015eimdi, yukar\u0131daki s\u0131n\u0131f\u0131m\u0131z std::atomic’i kullanarak g\u00fcvenli hale getirelim:<\/p>\n Kanaatimce, atomiklerin en b\u00fcy\u00fck avantaj\u0131, basit tipler i\u00e7in performans ve okunabilirlik. Bu sebeple, \u00f6zellikle basit veri tipleri i\u00e7in olabildi\u011fince std::atomics’leri kullanman\u0131z\u0131 tavsiye ediyorum.<\/p>\n C++ 20 ile birlikte bu tiplere baz\u0131 eklemeler de yap\u0131ld\u0131. Art\u0131k std::shared_ptr ve weak_ptr’da atomik olarak kullan\u0131labilecek. Detayl\u0131 bilgi i\u00e7in \u015fu sayfaya g\u00f6z atabilirsiniz:\u00a0https:\/\/en.cppreference.com\/w\/cpp\/atomic\/atomic<\/a><\/span><\/strong>.<\/p>\n Bu arada, atomik’ler ile ilgili bir di\u011fer konu da bellek s\u0131ralamas\u0131 (https:\/\/en.cppreference.com\/w\/cpp\/atomic\/memory_order<\/a><\/strong><\/span>) ki ben bu konuya girmedim. \u0130lgili referans dok\u00fcmanda da \u00f6zetlendi\u011fi gibi, bu mekanizma, atomik ve \u00f6nceki\/sonraki i\u015flemci komutlar\u0131n\u0131n nas\u0131l s\u0131raland\u0131\u011f\u0131n\u0131 tan\u0131ml\u0131yor. Bu konu ile ilgili daha detayl\u0131 bilgi almak i\u00e7in bahsetti\u011fim sayfaya g\u00f6z atabilirsiniz.<\/p>\n Bir sonraki yaz\u0131mda g\u00f6r\u00fc\u015fmek dile\u011fiyle \ud83d\ude42<\/p>\n <\/p>","protected":false},"excerpt":{"rendered":" Evet, thread ile ilgili yaz\u0131lar\u0131m\u0131za devam etme zaman\u0131 geldi. Bu yaz\u0131mda, sizlere thread k\u00fct\u00fcphanesi i\u00e7erisinde bulunan ve C++ kullanarak multithreaded yaz\u0131l\u0131m geli\u015ftirme esnas\u0131nda, size faydas\u0131 dokunaca\u011f\u0131n\u0131 d\u00fc\u015f\u00fcnd\u00fc\u011f\u00fcm yap\u0131lardan bahsedece\u011fim. Thread k\u00fct\u00fcphanesi ve ilgili girizgah\u0131 bir \u00f6nceki yaz\u0131mda yapm\u0131\u015ft\u0131m, e\u011fer onu okumad\u0131ysan\u0131z, mutlaka okuman\u0131z\u0131 \u00f6neririm. A\u015fa\u011f\u0131da ilgili yaz\u0131ma ve serinin di\u011fer yaz\u0131lar\u0131na ili\u015fkin ba\u011flant\u0131lar\u0131 bulabilirsiniz: Haftal\u0131k… Continue reading std::async:<\/span><\/strong><\/h2>\n
#include <iostream>\r\n#include <vector>\r\n#include <algorithm>\r\n#include <numeric>\r\n#include <future>\r\n \r\ntemplate <typename RandomIt>\r\nint parallel_sum(RandomIt beg, RandomIt end)\r\n{\r\n auto len = end - beg;\r\n if (len < 1000)\r\n return std::accumulate(beg, end, 0);\r\n \r\n RandomIt mid = beg + len\/2;\r\n auto handle = std::async(std::launch::async,\r\n parallel_sum<RandomIt>, mid, end);\r\n int sum = parallel_sum(beg, mid);\r\n return sum + handle.get();\r\n}\r\n \r\nint main()\r\n{\r\n std::vector<int> v(10000, 1);\r\n std::cout << \"The sum is \" << parallel_sum(v.begin(), v.end()) << '\\n';\r\n}<\/pre>\n\n
\n
\n
\n
#include <string>\r\n#include <chrono>\r\n#include <thread>\r\n#include <future>\r\n \r\nusing namespace std::chrono;\r\n \r\nstd::string fetchDataFromDB(std::string recvdData)\r\n{\r\n\t\/\/ Bu metodun tamamlanmas\u0131n\u0131n 5 saniye s\u00fcreci\u011fini garantile\r\n\tstd::this_thread::sleep_for(seconds(5));\r\n \r\n\t\/\/ Bu s\u0131rada veri taban\u0131 ba\u011flant\u0131s\u0131 ya da veri odakl\u0131 i\u015fleri halledebiliriz\r\n\treturn \"DB_\" + recvdData;\r\n}\r\n \r\nstd::string fetchDataFromFile(std::string recvdData)\r\n{\r\n \/\/ Bu metodun tamamlanmas\u0131n\u0131n 5 saniye s\u00fcreci\u011fini garantile\r\n\tstd::this_thread::sleep_for(seconds(5));\r\n \r\n\t\/\/ Bu s\u0131rada veri odakl\u0131 i\u015fleri halledebiliriz\r\n\treturn \"File_\" + recvdData;\r\n}\r\n \r\nint main()\r\n{\r\n\t\/\/ Ba\u015flang\u0131\u00e7 zaman\u0131n\u0131 tutual\u0131m\r\n\tsystem_clock::time_point start = system_clock::now();\r\n \r\n \/\/ A\u015fa\u011f\u0131daki kullan\u0131mda toplam s\u00fcreyi 5 saniyeye indiriyoruz\r\n\tstd::future<std::string> resultFromDB = std::async(std::launch::async, fetchDataFromDB, \"Data\");\r\n \r\n \/\/ A\u015fa\u011f\u0131daki kullan\u0131mda ise 10 sn bir s\u00fcre ge\u00e7iyor\r\n \/\/ std::string dbData = fetchDataFromDB(\"Data\");\r\n\r\n\t\/\/ Dosyadan veriyi \u00e7ekelim\r\n\tstd::string fileData = fetchDataFromFile(\"Data\");\r\n \r\n\t\/\/ Veri taban\u0131n veriyi \u00e7ekelim\r\n\t\/\/ future<std::string> object nesnesi haz\u0131r olana kadar bloklar.\r\n\tstd::string dbData = resultFromDB.get();\r\n \r\n\t\/\/ Biti\u015f zaman\u0131n\u0131 alal\u0131m\r\n\tauto end = system_clock::now();\r\n \r\n\tauto diff = duration_cast < std::chrono::seconds > (end - start).count();\r\n\tstd::cout << \"Total Time Taken = \" << diff << \" Seconds\" << std::endl;\r\n \r\n\t\/\/ Verileri birle\u015ftirelim\r\n\tstd::string data = dbData + \" :: \" + fileData;\r\n \r\n\t\/\/ Birle\u015ftirilmi\u015f veriyi basal\u0131m\r\n\tstd::cout << \"Data = \" << data << std::endl;\r\n \r\n\treturn 0;\r\n}<\/pre>\n\/\/ Sample from Scott Meyers' Blog\r\nvoid f()\r\n{\r\n std::future<void> fut = std::async(std::launch::async, \r\n [] { \/* compute, compute, compute *\/ });\r\n}<\/pre>\nstd::future & std::promise:<\/span><\/strong><\/h2>\n
![\"std::promise](\"https:\/\/thispointer.com\/\/wp-content\/uploads\/2015\/06\/promise.png\")
<\/p>\n#include <iostream>\r\n#include <thread>\r\n#include <future>\r\n#include <chrono>\r\n\r\nusing namespace std::chrono_literals;\r\n\r\nvoid initialize(std::promise<int> && promObj)\r\n{\r\n\tstd::cout << \"Update the value represented by passed promise as 65\" << '\\n';\r\n\r\n\t\/\/ 5 sn bekletelim\r\n\tstd::this_thread::sleep_for(5s);\r\n\r\n\t\/\/ \u00c7a\u011fr\u0131lan thread d\u00f6n\u00fclecek olan de\u011feri bunun \u00fczerinden iletir. Burada promObj.set_exception() arac\u0131l\u0131\u011f\u0131 ile ya da a\u015fa\u011f\u0131daki\r\n \/\/ kodu yorumlayarak hata durumu olu\u015fturabilirsiniz\r\n\tpromObj.set_value(65);\t\r\n}\r\n\r\nint main()\r\n{\r\n\tstd::promise<int> promiseObj;\r\n\tstd::future<int> futureObj = promiseObj.get_future();\r\n\r\n\t\/\/ \u0130lgili std::promise nesnesini yeni olu\u015fturulan threade ge\u00e7irelim\r\n\tstd::thread th(initialize, std::move(promiseObj));\r\n\tstd::cout << \"Wait till task is completed (about 5 seconds)\" << '\\n';\r\n\r\n\t\/\/ Olu\u015fturulan thread i\u015fini bitene kadar, mevcut thread bloklan\u0131r\r\n\tstd::cout << futureObj.get() << std::endl;\r\n\r\n \/\/ Olu\u015fturulan thread tamamlanana kadar bekle\r\n\tth.join();\r\n\r\n\treturn 0;\r\n}<\/pre>\n\n
\n
\/\/ promiseFuture.cpp\r\n\r\n#include <future>\r\n#include <iostream>\r\n#include <thread>\r\n#include <utility>\r\n\r\nvoid product(std::promise<int>&& intPromise, int a, int b)\r\n{\r\n intPromise.set_value(a*b);\r\n}\r\n\r\nstruct Div\r\n{\r\n void operator() (std::promise<int>&& intPromise, int a, int b) const \r\n {\r\n intPromise.set_value(a\/b);\r\n }\r\n};\r\n\r\nint main()\r\n{\r\n int a= 20;\r\n int b= 10;\r\n\r\n std::cout << '\\n';\r\n\r\n \/\/ \u0130lgili std::promise nesnelerini olu\u015ftural\u0131m\r\n std::promise<int> prodPromise;\r\n std::promise<int> divPromise;\r\n\r\n \/\/ Bunlardan std::future nesnelerini \u00e7ekelim\r\n std::future<int> prodResult= prodPromise.get_future();\r\n std::future<int> divResult= divPromise.get_future();\r\n\r\n \/\/ Hesaplamalar\u0131 ayr\u0131 bir thread'ten \u00e7ekelim\r\n std::thread prodThread(product,std::move(prodPromise),a,b);\r\n Div div;\r\n std::thread divThread(div,std::move(divPromise),a,b);\r\n\r\n \/\/ Sonu\u00e7lar\u0131 toplayal\u0131m\r\n std::cout << \"20*10= \" << prodResult.get() << '\\n';\r\n std::cout << \"20\/10= \" << divResult.get() << '\\n';\r\n\r\n prodThread.join(); \r\n divThread.join();\r\n\r\n std::cout << '\\n';\r\n}<\/pre>\n#include <iostream>\r\n#include <future>\r\n#include <chrono>\r\n \r\nint main()\r\n{ \r\n \/\/ \u0130lgili std::promise nesneleri\r\n std::promise<void> ready_promise, t1_ready_promise, t2_ready_promise;\r\n\r\n \/\/ \u0130lgili threadlere payla\u015ft\u0131r\u0131lacak olan std::shared_future nesnesi\r\n std::shared_future<void> ready_future(ready_promise.get_future());\r\n \r\n std::chrono::time_point<std::chrono::high_resolution_clock> start;\r\n\r\n \/\/ Birinci lambda fonksiyonu\r\n auto fun1 = [&, ready_future]() -> std::chrono::duration<double, std::milli> \r\n {\r\n \/\/ ana (main) thread'i haberdar et\r\n t1_ready_promise.set_value();\r\n\r\n \/\/ ana (main) thread'ten haber bekliyor\r\n ready_future.wait(); \r\n return std::chrono::high_resolution_clock::now() - start;\r\n };\r\n \r\n \/\/ \u0130kinci lambda fonksiyonu\r\n auto fun2 = [&, ready_future]() -> std::chrono::duration<double, std::milli> \r\n {\r\n \/\/ ana (main) thread'i haberdar et\r\n t2_ready_promise.set_value();\r\n \r\n \/\/ ana (main) thread'ten haber bekliyor\r\n ready_future.wait(); \r\n return std::chrono::high_resolution_clock::now() - start;\r\n };\r\n \r\n \/\/ \u0130lgili std::promise nesnelerinden std::future nesnelerini \u00e7ekelim\r\n auto fut1 = t1_ready_promise.get_future();\r\n auto fut2 = t2_ready_promise.get_future();\r\n \r\n \/\/ Thread'leri ba\u015flatal\u0131m\r\n auto result1 = std::async(std::launch::async, fun1);\r\n auto result2 = std::async(std::launch::async, fun2);\r\n \r\n \/\/ Threadlerden haber bekleyelim\r\n fut1.wait();\r\n fut2.wait();\r\n \r\n \/\/ Threadler haz\u0131rm\u0131\u015f\r\n start = std::chrono::high_resolution_clock::now();\r\n \r\n \/\/ \u015eimdi bekleyen thread'leri haberdar edelim \r\n ready_promise.set_value();\r\n \r\n std::cout << \"Thread 1 received the signal \"\r\n << result1.get().count() << \" ms after start\\n\"\r\n << \"Thread 2 received the signal \"\r\n << result2.get().count() << \" ms after start\\n\";\r\n\r\n return 0;\r\n}<\/pre>\nstd::<\/span>packaged_task:<\/span><\/h2>\n
\n
#include <iostream>\r\n#include <cmath>\r\n#include <thread>\r\n#include <future>\r\n#include <functional>\r\n \r\n\/\/ Say\u0131n\u0131n \u00fcss\u00fcn\u00fc hesaplama i\u00e7in \u00f6rnek fonksiyon\r\nint f(int x, int y) \r\n{ \r\n return std::pow(x, y); \r\n}\r\n \r\nvoid taskLambda()\r\n{\r\n \/\/ packaged_task nesnesi lambda fonksiyonu ile\r\n std::packaged_task<int(int,int)> task([](int a, int b) \r\n {\r\n return std::pow(a, b); \r\n });\r\n\r\n \/\/ Sonu\u00e7 kontrol etmek i\u00e7in future nesnesini edinelim\r\n std::future<int> result = task.get_future();\r\n \r\n \/\/ \u0130\u015flevi ba\u015flatal\u0131m\r\n task(2, 9);\r\n \r\n \/\/ Sonu\u00e7 i\u00e7in bekleyelim\r\n std::cout << \"taskLambda:\\t\" << result.get() << '\\n';\r\n}\r\n \r\nvoid taskBind()\r\n{\r\n \/\/ packaged_task metot ba\u011flama kullan\u0131m\u0131\r\n std::packaged_task<int()> task(std::bind(f, 2, 11));\r\n std::future<int> result = task.get_future();\r\n \r\n \/\/ \u0130\u015flevi ba\u015flatal\u0131m\r\n task();\r\n \r\n std::cout << \"taskBind:\\t\" << result.get() << '\\n';\r\n}\r\n \r\nvoid taskThread()\r\n{\r\n \/\/ packaged_task standart fonksiyon ile kullan\u0131m\u0131\r\n std::packaged_task<int(int,int)> task(f);\r\n std::future<int> result = task.get_future();\r\n \r\n \/\/ \u0130lgili threade std::packaged_task nesnesini ge\u00e7irelim ve i\u015flevi ba\u015flatal\u0131m\r\n std::thread task_td(std::move(task), 2, 10);\r\n\r\n \/\/ Threadin tamamlanmas\u0131n\u0131 bekleyelim\r\n task_td.join();\r\n \r\n std::cout << \"taskThread:\\t\" << result.get() << '\\n';\r\n}\r\n \r\nint main()\r\n{\r\n taskLambda();\r\n taskBind();\r\n taskThread();\r\n\r\n return 0;\r\n}<\/pre>\n\n
Atomics:<\/span><\/h2>\n
class ShredCounter \r\n{\r\npublic:\r\n void increment()\r\n {\r\n ++mValue;\r\n }\r\n\u00a0 \u00a0\u00a0\r\n void decrement()\r\n {\r\n --mValue;\r\n }\r\n\u00a0 \u00a0\u00a0\r\n int get() \r\n {\r\n return mValue\r\n }\r\n\r\n void set(int newValue)\r\n {\r\n mValue = newValue;\r\n }\r\nprivate: \r\n \/\/ Payla\u015f\u0131lacak olan veri\r\n int mValue;\r\n};<\/pre>\n<atomic><\/code>\u00a0ba\u015fl\u0131k dosyas\u0131n\u0131 eklemeniz gerekiyor. Bu s\u0131n\u0131f\u0131n \u015fablon parametresi olarak da payla\u015fmak istedi\u011finiz veri tipini giriyorsunuz (k\u00fct\u00fcphane i\u00e7erisinde bilindik veri tipleri i\u00e7in haz\u0131r tipler mevcut. Bu yap\u0131n\u0131n alt tarafta kulland\u0131\u011f\u0131 senkronizasyon mekanizmas\u0131, ilgili k\u00fct\u00fcphane ger\u00e7eklemesine ve parametre olarak ge\u00e7irilen tipe ba\u011fl\u0131. Basit veri tipleri i\u00e7in, \u00f6r. int, long, float, bool, vb., std::mutex ve benzeri yap\u0131lardan \u00e7ok daha performansl\u0131 ve “lock-free” \u015fekilde eri\u015fim sa\u011flanabilir (tabi burada “lock-free” olmas\u0131 i\u015flemci taraf\u0131ndan sunulan i\u015flemci komutlar\u0131na ba\u011fl\u0131).\u00a0 E\u011fer daha karma\u015f\u0131k tipler kullan\u0131r iseniz de, sistem, arka tarafta std::mutex’leri kullanarak gerekli senkronizasyon i\u015flevini yerine getiriyor. Bu arada “lock-free” deste\u011fi ayr\u0131ca sunulan\u00a0is_lock_free()<\/em> API’is ile de kontrol edilebilir. https:\/\/en.cppreference.com\/w\/cpp\/atomic\/atomic\/is_lock_free<\/span><\/strong>\u00a0sayfas\u0131ndan ald\u0131\u011f\u0131m a\u015fa\u011f\u0131daki \u00f6rnek kod ile devam edelim:<\/p>\n#include <iostream>\r\n#include <utility>\r\n#include <atomic>\r\n\u00a0\r\nstruct A \r\n{ \r\n int a[100]; \r\n};\r\nstruct B \r\n{ \r\n int x;\r\n int y; \r\n};\r\nint main()\r\n{\r\n std::cout << std::boolalpha\r\n << \"std::atomic<A> is lock free? \"\r\n << std::atomic<A>{}.is_lock_free() << '\\n'\r\n << \"std::atomic<B> is lock free? \"\r\n << std::atomic<B>{}.is_lock_free() << '\\n';\r\n}<\/pre>\n#include <atomic>\r\n\r\nclass ShredCounter \r\n{\r\npublic:\r\n void increment()\r\n {\r\n ++mValue;\r\n }\r\n\u00a0 \u00a0\u00a0\r\n void decrement()\r\n {\r\n --mValue;\r\n }\r\n\u00a0 \u00a0\u00a0\r\n int get() \r\n {\r\n return mValue.load();\r\n }\r\n\r\n void set(int newValue)\r\n {\r\n mValue.store(newValue);\r\n }\r\nprivate: \r\n \/\/ Thread'ler taraf\u0131ndan payla\u015f\u0131lacak de\u011fi\u015fken\r\n std::atomic<int> mValue;\r\n};<\/pre>\nReferanslar:<\/strong><\/span><\/h2>\n
\n