دسترسی نامحدود
برای کاربرانی که ثبت نام کرده اند
دانلود کتاب Concurrency with Modern C++ What every professional C++ programmer should know about concurrency.
دانلود کتاب همزمانی با C++ مدرن آنچه که هر برنامه نویس حرفه ای سی پلاس پلاس باید در مورد همزمانی بداند.
مشخصات کتاب
Concurrency with Modern C++ What every professional C++ programmer should know about concurrency.
ویرایش:
نویسندگان: Rainer Grimm
سری:
ناشر:
سال نشر: 2022
تعداد صفحات: [727]
زبان: English
فرمت فایل : PDF (درصورت درخواست کاربر به PDF، EPUB یا AZW3 تبدیل می شود)
حجم فایل: 12 Mb
قیمت کتاب (تومان) : 50,000
در صورت تبدیل فایل کتاب Concurrency with Modern C++ What every professional C++ programmer should know about concurrency. به فرمت های PDF، EPUB، AZW3، MOBI و یا DJVU می توانید به پشتیبان اطلاع دهید تا فایل مورد نظر را تبدیل نمایند.
توجه داشته باشید کتاب همزمانی با C++ مدرن آنچه که هر برنامه نویس حرفه ای سی پلاس پلاس باید در مورد همزمانی بداند. نسخه زبان اصلی می باشد و کتاب ترجمه شده به فارسی نمی باشد. وبسایت اینترنشنال لایبرری ارائه دهنده کتاب های زبان اصلی می باشد و هیچ گونه کتاب ترجمه شده یا نوشته شده به فارسی را ارائه نمی دهد.
توضیحاتی درمورد کتاب به خارجی
فهرست مطالب
Table of Contents Reader Testimonials Introduction Conventions Special Fonts Special Symbols Special Boxes Source Code Run the Programs How should you read the book? Personal Notes Acknowledgment About Me My Special Circumstances A Quick Overview Concurrency with Modern C++ C++11 and C++14: The Foundation Memory Model Multithreading C++17: Parallel Algorithms of the Standard Template Library Execution Policy New Algorithms Coroutines Case Studies Calculating the Sum of a Vector The Dining Philosophers Problem by Andre Adrian Thread-Safe Initialization of a Singleton Ongoing Optimization with CppMem Fast Synchronization of Threads Variations of Futures Modification and Generalization of a Generator Various Job Workflows The Future: C++23 Executors Extended futures Transactional Memory Task Blocks Data-Parallel Vector Library Patterns and Best Practices Synchronization Concurrent Architecture Best Practices Data Structures Challenges Time Library CppMem Glossary The Details Memory Model Basics of the Memory Model What is a memory location? What happens if two threads access the same memory location? The Contract The Foundation The Challenges Atomics Strong versus Weak Memory Model The Atomic Flag std::atomic All Atomic Operations Free Atomic Functions std::atomic_ref (C++20) The Synchronization and Ordering Constraints The Six Variants of Memory Orderings in C++ Sequential Consistency Acquire-Release Semantic std::memory_order_consume Relaxed Semantic Fences std::atomic_thread_fence std::atomic_signal_fence Multithreading The Basic Thread std::thread Thread Creation Thread Lifetime Thread Arguments Member Functions The Improved Thread std::jthread (C++20) Automatically Joining Cooperative Interruption of a std::jthread Shared Data Mutexes Locks std::lock Thread-safe Initialization Thread-Local Data Condition Variables The Predicate Lost Wakeup and Spurious Wakeup The Wait Workflow Cooperative Interruption (C++20) std::stop_source std::stop_token std::stop_callback A General Mechanism to Send Signals Additional Functionality of std::jthread New wait Overloads for the condition_variable_any Semaphores (C++20) Latches and Barriers (C++20) std::latch std::barrier Tasks Tasks versus Threads std::async std::packaged_task std::promise and std::future std::shared_future Exceptions Notifications Synchronized Outputstreams (C++20) Parallel Algorithms of the Standard Template Library Execution Policies Parallel and Vectorized Execution Exceptions Hazards of Data Races and Deadlocks Algorithms The New Algorithms More overloads The functional Heritage Compiler Support Microsoft Visual Compiler GCC Compiler Further Implementations of the Parallel STL Performance Microsoft Visual Compiler GCC Compiler Coroutines (C++20) A Generator Function Characteristics Typical Use Cases Underlying Concepts Design Goals Becoming a Coroutine The Framework Promise Object Coroutine Handle Coroutine Frame Awaitables and Awaiters Awaitables The Concept Awaiter std::suspend_always and std::suspend_never initial_suspend final_suspend Awaiter The Workflows The Promise Workflow The Awaiter Workflow co_return A Future co_yield An Infinite Data Stream co_await Starting a Job on Request Thread Synchronization Case Studies Calculating the Sum of a Vector Single Threaded addition of a Vector Multithreaded Summation with a Shared Variable Thread-Local Summation Summation of a Vector: The Conclusion The Dining Philosophers Problem by Andre Adrian Multiple Resource Use Multiple Resource Use with Logging Erroneous Busy Waiting without Resource Hierarchy Erroneous Busy Waiting with Resource Hierarchy Still Erroneous Busy Waiting with Resource Hierarchy Correct Busy Waiting with Resource Hierarchy Good low CPU load Busy Waiting with Resource Hierarchy std::mutex with Resource Hierarchy std::lock_guard with Resource Hierarchy std::lock_guard and Synchronized Output with Resource Hierarchy std::lock_guard and Synchronized Output with Resource Hierarchy and a count A std::unique_lock using deferred locking A std::scoped_lock with Resource Hierarchy The Original Dining Philosophers Problem using Semaphores A C++20 Compatible Semaphore Thread-Safe Initialization of a Singleton Double-Checked Locking Pattern Performance Measurement Thread-Safe Meyers Singleton std::lock_guard std::call_once with std::once_flag Atomics Performance Numbers of the various Thread-Safe Singleton Implementations Ongoing Optimization with CppMem CppMem: Non-Atomic Variables CppMem: Locks CppMem: Atomics with Sequential Consistency CppMem: Atomics with Acquire-Release Semantic CppMem: Atomics with Non-atomics CppMem: Atomics with Relaxed Semantic Conclusion Fast Synchronization of Threads Condition Variables std::atomic_flag std::atomicSemaphores All Numbers Variations of Futures A Lazy Future Execution on Another Thread Modification and Generalization of a Generator Modifications Generalization Various Job Workflows The Transparent Awaiter Workflow Automatically Resuming the Awaiter Automatically Resuming the Awaiter on a Separate Thread The Future: C++23 Executors A long Way What is an Executor? First Examples Goals of an Executor Concept Terminology Execution Functions A Prototype Implementation Extended Futures Concurrency TS v1 Unified Futures Transactional Memory ACI(D) Synchronized and Atomic Blocks transaction_safe versus transaction_unsafe Code Task Blocks Fork and Join define_task_block versus define_task_block_restore_thread The Interface The Scheduler Data-Parallel Vector Library Data-Parallel Vectors The Interface of the Data-Parallel Vectors Patterns Patterns and Best Practices History Invaluable Value Pattern versus Best Practices Anti-Pattern Synchronization Patterns Dealing with Sharing Copied Value Thread-Specific Storage Future Dealing with Mutation Scoped Locking Strategized Locking Thread-Safe Interface Guarded Suspension Concurrent Architecture Active Object Challenges Solution Components Dynamic Behavior Advantages and Disadvantages Implementation Monitor Object Challenges Solution Components Dynamic Behavior Advantages and Disadvantages Half-Sync/Half-Async Challenges Solution Components Dynamic Behavior Advantages and Disadvantages Example Reactor Challenges Solution Components Dynamic Behavior Advantages and Disadvantages Example Proactor Challenges Solution Components Advantages and Disadvantages Example Further Information Best Practices General Code Reviews Minimize Sharing of Mutable Data Minimize Waiting Prefer Immutable Data Use pure functions Look for the Right Abstraction Use Static Code Analysis Tools Use Dynamic Enforcement Tools Multithreading Threads Data Sharing Condition Variables Promises and Futures Memory Model Don't use volatile for synchronization Don't program Lock Free If you program Lock-Free, use well-established patterns Don't build your abstraction, use guarantees of the language Don't reinvent the wheel Data Structures General Considerations Concurrent Stack Locking Strategy Granularity of the Interface Typical Usage Pattern Linux (GCC) Windows (cl.exe) Avoidance of Loopholes Contention Single-Threaded Summation without Synchronization Single-Threaded Summation with Synchronization (lock) Single-Threaded Summation with Synchronization (atomic) The Comparison Scalability Invariants Exceptions Lock-Based Data Structures A Stack Concurrent Queue A Queue Coarse-Grained Locking Fine-Grained Locking Lock-Free Data Structures General Considerations The Next Evolutionary Step Sequential Consistency Concurrent Stack A Simplified Implementation A Complete Implementation Concurrent Queue Further Information Challenges ABA Problem Blocking Issues Breaking of Program Invariants Data Races Deadlocks False Sharing Lifetime Issues of Variables Moving Threads Race Conditions The Time Library The Interplay of Time Point, Time Duration, and Clock Time Point From Time Point to Calendar Time Cross the valid Time Range Time Duration Calculations Clocks Accuracy and Steadiness Epoch Sleep and Wait CppMem - An Overview The simplified Overview 1. Model 2. Program 3. Display Relations 4. Display Layout 5. Model Predicates The Examples Glossary adress_free ACID CAS Callable Unit Complexity Concepts Concurrency Critical Section Deadlock Eager Evaluation Executor Function Objects Lambda Functions Lazy evaluation Lock-free Lock-based Lost Wakeup Math Laws Memory Location Memory Model Modification Order Monad Non-blocking obstruction-free Parallelism Predicate Pattern RAII Release Sequence Sequential Consistency Sequence Point Spurious Wakeup Thread Total order TriviallyCopyable Undefined Behavior volatile wait-free Index
