فلش‌کارت‌های آموزشی برنامه نویسی همزمان و چندنخی (Concurrency & Multithreading) در C++

🎓 دوره آموزشی جامع

📚 اطلاعات دوره

عنوان دوره: دوره برنامه نویسی همزمان و چندنخی (Concurrency & Multithreading) در C++

موضوع کلی: برنامه نویسی

موضوع میانی: سی پلاس پلاس (++C)

📋 سرفصل‌های دوره

• 1. مقدمه‌ای بر همزمانی (Concurrency) و توازی (Parallelism)
• 2. چرا به برنامه‌نویسی همزمان نیاز داریم؟
• 3. تاریخچه همزمانی در سی پلاس پلاس
• 4. فرآیندها (Processes) در برابر نخ‌ها (Threads)
• 5. مدل حافظه سی پلاس پلاس: یک نگاه کلی
• 6. چالش‌های برنامه‌نویسی همزمان: Race Condition
• 7. چالش‌های برنامه‌نویسی همزمان: Deadlock
• 8. چالش‌های برنامه‌نویسی همزمان: Livelock و Starvation
• 9. معماری سخت‌افزار: هسته‌های CPU، حافظه نهان (Cache) و انسجام حافظه
• 10. قانون امدال (Amdahl's Law) و قانون گوستافسون (Gustafson's Law)
• 11. راه‌اندازی محیط توسعه برای برنامه‌نویسی چندنخی
• 12. اولین برنامه چندنخی: ساخت و اجرای یک نخ با `std::thread`
• 13. مدیریت چرخه حیات نخ: `join()`
• 14. مدیریت چرخه حیات نخ: `detach()`
• 15. خطرات استفاده از نخ‌های جدا شده (Detached Threads)
• 16. انتقال آرگومان به توابع نخ‌ها
• 17. پاس دادن آرگومان‌ها با ارجاع (Reference) و `std::ref`
• 18. انتقال مالکیت `std::thread` با `std::move`
• 19. شناسایی نخ‌ها: `std::thread::id` و `std::this_thread::get_id`
• 20. مدیریت استثناها (Exceptions) در نخ‌ها
• 21. الگوی RAII برای مدیریت خودکار نخ‌ها (Scoped Thread)
• 22. فضای نام `std::this_thread`: توابع `sleep_for`, `sleep_until`, `yield`
• 23. مقدمه‌ای بر همگام‌سازی و نیاز به قفل‌ها
• 24. حفاظت از داده‌های اشتراکی با `std::mutex`
• 25. قفل‌گذاری و آزادسازی دستی: `lock()` و `unlock()`
• 26. مشکلات قفل‌گذاری دستی: بن‌بست و مدیریت استثنا
• 27. الگوی RAII برای قفل‌ها: `std::lock_guard`
• 28. قفل‌گذاری انعطاف‌پذیر با `std::unique_lock`
• 29. تلاش برای قفل‌گذاری: `try_lock()`
• 30. قفل‌گذاری با زمان انتظار: `try_lock_for()` و `try_lock_until()`
• 31. انتقال مالکیت قفل با `std::unique_lock`
• 32. جلوگیری از بن‌بست: قفل‌گذاری چندین Mutex با `std::lock`
• 33. قفل‌گذاری امن چندین Mutex با `std::scoped_lock` (C++17)
• 34. انواع خاص Mutex: `std::recursive_mutex`
• 35. معایب و موارد استفاده صحیح از `recursive_mutex`
• 36. انواع خاص Mutex: `std::timed_mutex`
• 37. شرایط مسابقه (Data Race) و رفتار تعریف‌نشده (Undefined Behavior)
• 38. مقدمه‌ای بر متغیرهای شرطی (Condition Variables)
• 39. انتظار برای یک شرط با `std::condition_variable` و `wait()`
• 40. ارسال سیگنال به نخ‌های منتظر: `notify_one()`
• 41. ارسال سیگنال به تمام نخ‌های منتظر: `notify_all()`
• 42. مشکل بیداری‌های کاذب (Spurious Wakeups) و نحوه مدیریت آن
• 43. پیاده‌سازی الگوی تولیدکننده-مصرف‌کننده (Producer-Consumer)
• 44. استفاده از `std::condition_variable_any`
• 45. ارتباط بین نخ‌ها: بازگرداندن مقادیر با `std::future`
• 46. ایجاد `future` با استفاده از `std::promise`
• 47. ایجاد `future` با استفاده از `std::packaged_task`
• 48. اجرای ناهمزمان توابع با `std::async`
• 49. سیاست‌های اجرا (Launch Policies) در `std::async`
• 50. انتظار برای نتیجه `future`: `get()`, `wait()`, `wait_for()`
• 51. انتشار استثناها از طریق `future` و `promise`
• 52. اشتراک‌گذاری نتیجه بین چند نخ با `std::shared_future`
• 53. اجرای یکباره یک تابع با `std::call_once` و `std::once_flag`
• 54. قفل‌های خواننده-نویسنده با `std::shared_mutex` (C++17)
• 55. قفل‌گذاری برای خواندن با `std::shared_lock` (C++17)
• 56. همگام‌سازی گروهی از نخ‌ها با `std::latch` (C++20)
• 57. همگام‌سازی چرخه‌ای با `std::barrier` (C++20)
• 58. مدیریت منابع محدود با `std::counting_semaphore` (C++20)
• 59. مقدمه‌ای بر عملیات اتمیک (Atomic Operations)
• 60. کلاس قالب `std::atomic<T>`
• 61. عملیات پایه‌ای اتمیک: `load`, `store`
• 62. عملیات خواندن-تغییر-نوشتن: `exchange`, `compare_exchange_strong/weak`
• 63. عملیات محاسباتی اتمیک: `fetch_add`, `fetch_sub`
• 64. ساده‌ترین نوع اتمیک: `std::atomic_flag`
• 65. برنامه‌نویسی بدون قفل (Lock-Free Programming): مفاهیم اولیه
• 66. پیاده‌سازی یک شمارنده اتمیک بدون قفل
• 67. پیاده‌سازی یک پشته (Stack) بدون قفل
• 68. مشکل ABA در الگوریتم‌های بدون قفل
• 69. مدل حافظه سی پلاس پلاس: روابط Happens-Before و Synchronizes-With
• 70. ترتیب حافظه (Memory Ordering): Sequential Consistency
• 71. ترتیب حافظه: Acquire-Release Semantics
• 72. ترتیب حافظه: Relaxed Ordering
• 73. استفاده عملی از ترتیب‌های مختلف حافظه
• 74. حصارهای حافظه (Memory Fences) با `std::atomic_thread_fence`
• 75. الگوهای طراحی همزمان: Thread Pool
• 76. پیاده‌سازی یک Thread Pool ساده
• 77. ارسال وظایف (Tasks) به Thread Pool و دریافت نتایج
• 78. الگوی طراحی Active Object
• 79. الگوی طراحی Monitor Object
• 80. حافظه محلی نخ (Thread-Local Storage) با `thread_local`
• 81. طراحی ساختارهای داده همزمان (Concurrent Data Structures)
• 82. استراتژی‌های تقسیم کار بین نخ‌ها
• 83. الگوی Fork-Join
• 84. مقابله با وظایف وابسته به CPU در مقابل وظایف وابسته به I/O
• 85. لغو کردن (Cancellation) وظایف در حال اجرا
• 86. خاتمه دادن امن و صحیح به یک سیستم همزمان
• 87. مقدمه‌ای بر الگوریتم‌های موازی در کتابخانه استاندارد (C++17)
• 88. سیاست‌های اجرا (Execution Policies): `seq`, `par`, `par_unseq`
• 89. استفاده از الگوریتم‌های موازی: `for_each`, `transform`
• 90. استفاده از الگوریتم‌های موازی: `reduce`, `sort`
• 91. مدیریت استثناها در الگوریتم‌های موازی
• 92. برداری‌سازی (Vectorization) و نقش آن در `par_unseq`
• 93. انتخاب سیاست اجرای مناسب
• 94. اشکال‌زدایی (Debugging) برنامه‌های چندنخی: چالش‌ها
• 95. استفاده از ابزارهای Thread Sanitizer برای یافتن Data Race
• 96. استفاده از ابزارهایی مانند Helgrind
• 97. پروفایل‌سازی (Profiling) و تحلیل عملکرد برنامه‌های همزمان
• 98. مفهوم اشتراک کاذب (False Sharing) و راه‌های جلوگیری از آن
• 99. اندازه‌گیری مقیاس‌پذیری (Scalability) و شناسایی گلوگاه‌ها
• 100. بهترین شیوه‌ها و اشتباهات رایج در برنامه‌نویسی همزمان