logo资料库

C++ Concurrency in Action - Practical Multithreading 无水印pdf.pdf

发布时间：2022-05-30 发布人：admin 分类：说明书 资料大小：3.61M 资料格式：pdf 举报 版权申诉
第1页 / 共530页
第2页 / 共530页
第3页 / 共530页
第4页 / 共530页
第5页 / 共530页
第6页 / 共530页
第7页 / 共530页
第8页 / 共530页
资料共530页，剩余部分请下载后查看
    Cover
    brief contents
    contents
    preface
    acknowledgments
    about this book
    Roadmap
    Who should read this book
    How to use this book
    Code conventions and downloads
    Software requirements
    Author Online
    about the cover illustration
    1 Hello, world of concurrency in C++!
    1.1 What is concurrency?
    1.1.1 Concurrency in computer systems
    1.1.2 Approaches to concurrency
    1.2 Why use concurrency?
    1.2.1 Using concurrency for separation of concerns
    1.2.2 Using concurrency for performance
    1.2.3 When not to use concurrency
    1.3 Concurrency and multithreading in C++
    1.3.1 History of multithreading in C++
    1.3.2 Concurrency support in the new standard
    1.3.3 Efficiency in the C++ Thread Library
    1.3.4 Platform-specific facilities
    1.4 Getting started
    1.4.1 Hello, Concurrent World
    1.5 Summary
    2 Managing threads
    2.1 Basic thread management
    2.1.1 Launching a thread
    2.1.2 Waiting for a thread to complete
    2.1.3 Waiting in exceptional circumstances
    2.1.4 Running threads in the background
    2.2 Passing arguments to a thread function
    2.3 Transferring ownership of a thread
    2.4 Choosing the number of threads at runtime
    2.5 Identifying threads
    2.6 Summary
    3 Sharing data between threads
    3.1 Problems with sharing data between threads
    3.1.1 Race conditions
    3.1.2 Avoiding problematic race conditions
    3.2 Protecting shared data with mutexes
    3.2.1 Using mutexes in C++
    3.2.2 Structuring code for protecting shared data
    3.2.3 Spotting race conditions inherent in interfaces
    3.2.4 Deadlock: the problem and a solution
    3.2.5 Further guidelines for avoiding deadlock
    3.2.6 Flexible locking with std::unique_lock
    3.2.7 Transferring mutex ownership between scopes
    3.2.8 Locking at an appropriate granularity
    3.3 Alternative facilities for protecting shared data
    3.3.1 Protecting shared data during initialization
    3.3.2 Protecting rarely updated data structures
    3.3.3 Recursive locking
    3.4 Summary
    4 Synchronizing concurrent operations
    4.1 Waiting for an event or other condition
    4.1.1 Waiting for a condition with condition variables
    4.1.2 Building a thread-safe queue with condition variables
    4.2 Waiting for one-off events with futures
    4.2.1 Returning values from background tasks
    4.2.2 Associating a task with a future
    4.2.3 Making (std::)promises
    4.2.4 Saving an exception for the future
    4.2.5 Waiting from multiple threads
    4.3 Waiting with a time limit
    4.3.1 Clocks
    4.3.2 Durations
    4.3.3 Time points
    4.3.4 Functions that accept timeouts
    4.4 Using synchronization of operations to simplify code
    4.4.1 Functional programming with futures
    4.4.2 Synchronizing operations with message passing
    4.5 Summary
    5 The C++ memory model and operations on atomic types
    5.1 Memory model basics
    5.1.1 Objects and memory locations
    5.1.2 Objects, memory locations, and concurrency
    5.1.3 Modification orders
    5.2 Atomic operations and types in C++
    5.2.1 The standard atomic types
    5.2.2 Operations on std::atomic_flag
    5.2.3 Operations on std::atomic
    5.2.4 Operations on std::atomic: pointer arithmetic
    5.2.5 Operations on standard atomic integral types
    5.2.6 The std::atomic<> primary class template
    5.2.7 Free functions for atomic operations
    5.3 Synchronizing operations and enforcing ordering
    5.3.1 The synchronizes-with relationship
    5.3.2 The happens-before relationship
    5.3.3 Memory ordering for atomic operations
    5.3.4 Release sequences and synchronizes-with
    5.3.5 Fences
    5.3.6 Ordering nonatomic operations with atomics
    5.4 Summary
    6 Designing lock-based concurrent data structures
    6.1 What does it mean to design for concurrency?
    6.1.1 Guidelines for designing data structures for concurrency
    6.2 Lock-based concurrent data structures
    6.2.1 A thread-safe stack using locks
    6.2.2 A thread-safe queue using locks and condition variables
    6.2.3 A thread-safe queue using fine-grained locks and condition variables
    6.3 Designing more complex lock-based data structures
    6.3.1 Writing a thread-safe lookup table using locks
    6.3.2 Writing a thread-safe list using locks
    6.4 Summary
    7 Designing lock-free concurrent data structures
    7.1 Definitions and consequences
    7.1.1 Types of nonblocking data structures
    7.1.2 Lock-free data structures
    7.1.3 Wait-free data structures
    7.1.4 The pros and cons of lock-free data structures
    7.2 Examples of lock-free data structures
    7.2.1 Writing a thread-safe stack without locks
    7.2.2 Stopping those pesky leaks: managing memory in lock-free data structures
    7.2.3 Detecting nodes that can't be reclaimed using hazard pointers
    7.2.4 Detecting nodes in use with reference counting
    7.2.5 Applying the memory model to the lock-free stack
    7.2.6 Writing a thread-safe queue without locks
    7.3 Guidelines for writing lock-free data structures
    7.3.1 Guideline: use std::memory_order_seq_cst for prototyping
    7.3.2 Guideline: use a lock-free memory reclamation scheme
    7.3.3 Guideline: watch out for the ABA problem
    7.3.4 Guideline: identify busy-wait loops and help the other thread
    7.4 Summary
    8 Designing concurrent code
    8.1 Techniques for dividing work between threads
    8.1.1 Dividing data between threads before processing begins
    8.1.2 Dividing data recursively
    8.1.3 Dividing work by task type
    8.2 Factors affecting the performance of concurrent code
    8.2.1 How many processors?
    8.2.2 Data contention and cache ping-pong
    8.2.3 False sharing
    8.2.4 How close is your data?
    8.2.5 Oversubscription and excessive task switching
    8.3 Designing data structures for multithreaded performance
    8.3.1 Dividing array elements for complex operations
    8.3.2 Data access patterns in other data structures
    8.4 Additional considerations when designing for concurrency
    8.4.1 Exception safety in parallel algorithms
    8.4.2 Scalability and Amdahl's law
    8.4.3 Hiding latency with multiple threads
    8.4.4 Improving responsiveness with concurrency
    8.5 Designing concurrent code in practice
    8.5.1 A parallel implementation of std::for_each
    8.5.2 A parallel implementation of std::find
    8.5.3 A parallel implementation of std::partial_sum
    8.6 Summary
    9 Advanced thread management
    9.1 Thread pools
    9.1.1 The simplest possible thread pool
    9.1.2 Waiting for tasks submitted to a thread pool
    9.1.3 Tasks that wait for other tasks
    9.1.4 Avoiding contention on the work queue
    9.1.5 Work stealing
    9.2 Interrupting threads
    9.2.1 Launching and interrupting another thread
    9.2.2 Detecting that a thread has been interrupted
    9.2.3 Interrupting a condition variable wait
    9.2.4 Interrupting a wait on std::condition_variable_any
    9.2.5 Interrupting other blocking calls
    9.2.6 Handling interruptions
    9.2.7 Interrupting background tasks on application exit
    9.3 Summary
    10 Testing and debugging multithreaded applications
    10.1 Types of concurrency-related bugs
    10.1.1 Unwanted blocking
    10.1.2 Race conditions
    10.2 Techniques for locating concurrency-related bugs
    10.2.1 Reviewing code to locate potential bugs
    10.2.2 Locating concurrency-related bugs by testing
    10.2.3 Designing for testability
    10.2.4 Multithreaded testing techniques
    10.2.5 Structuring multithreaded test code
    10.2.6 Testing the performance of multithreaded code
    10.3 Summary
    appendix A Brief reference for some C++11 language features
    A.1 Rvalue references
    A.1.1 Move semantics
    A.1.2 Rvalue references and function templates
    A.2 Deleted functions
    A.3 Defaulted functions
    A.4 constexpr functions
    A.4.1 constexpr and user-defined types
    A.4.2 constexpr objects
    A.4.3 constexpr function requirements
    A.4.4 constexpr and templates
    A.5 Lambda functions
    A.5.1 Lambda functions that reference local variables
    A.6 Variadic templates
    A.6.1 Expanding the parameter pack
    A.7 Automatically deducing the type of a variable
    A.8 Thread-local variables
    A.9 Summary
    appendix B Brief comparison of concurrency libraries
    appendix C A message-passing framework and complete ATM example
    appendix D C++ Thread Library reference
    D.1 The header
    D.1.1 std::chrono::duration class template
    D.1.2 std::chrono::time_point class template
    D.1.3 std::chrono::system_clock class
    D.1.4 std::chrono::steady_clock class
    D.1.5 std::chrono::high_resolution_clock typedef
    D.2 header
    D.2.1 std::condition_variable class
    D.2.2 std::condition_variable_any class
    D.3 header
    D.3.1 std::atomic_xxx typedefs
    D.3.2 ATOMIC_xxx_LOCK_FREE macros
    D.3.3 ATOMIC_VAR_INIT macro
    D.3.4 std::memory_order enumeration
    D.3.5 std::atomic_thread_fence function
    D.3.6 std::atomic_signal_fence function
    D.3.7 std::atomic_flag class
    D.3.8 std::atomic class template
    D.3.9 Specializations of the std::atomic template
    D.3.10 std::atomic specializations
    D.4 header
    D.4.1 std::future class template
    D.4.2 std::shared_future class template
    D.4.3 std::packaged_task class template
    D.4.4 std::promise class template
    D.4.5 std::async function template
    D.5 header
    D.5.1 std::mutex class
    D.5.2 std::recursive_mutex class
    D.5.3 std::timed_mutex class
    D.5.4 std::recursive_timed_mutex class
    D.5.5 std::lock_guard class template
    D.5.6 std::unique_lock class template
    D.5.7 std::lock function template
    D.5.8 std::try_lock function template
    D.5.9 std::once_flag class
    D.5.10 std::call_once function template
    D.6 header
    D.6.1 std::ratio class template
    D.6.2 std::ratio_add template alias
    D.6.3 std::ratio_subtract template alias
    D.6.4 std::ratio_multiply template alias
    D.6.5 std::ratio_divide template alias
    D.6.6 std::ratio_equal class template
    D.6.7 std::ratio_not_equal class template
    D.6.8 std::ratio_less class template
    D.6.9 std::ratio_greater class template
    D.6.10 std::ratio_less_equal class template
    D.6.11 std::ratio_greater_equal class template
    D.7 header
    D.7.1 std::thread class
    D.7.2 Namespace this_thread
    resources
    Print resources
    Online resources
    index
    Symbols
    A
    B
    C
    D
    E
    F
    G
    H
    I
    J
    L
    M
    N
    O
    P
    Q
    R
    S
    T
    U
    V
    W
    Back cover
    IN ACTION Practical Multithreading Anthony Williams M A N N I N G
    C++ Concurrency in Action
    C++ Concurrency in Action PRACTICAL MULTITHREADING ANTHONY WILLIAMS M A N N I N G SHELTER ISLAND
    For online information and ordering of this and other Manning books, please visit www.manning.com. The publisher offers discounts on this book when ordered in quantity. For more information, please contact Special Sales Department Manning Publications Co. 20 Baldwin Road PO Box 261 Shelter Island, NY 11964 Email: orders@manning.com ©2012 by Manning Publications Co. All rights reserved. No part of this publication may be reproduced, stored in a retrieval system, or transmitted, in any form or by means electronic, mechanical, photocopying, or otherwise, without prior written permission of the publisher. Many of the designations used by manufacturers and sellers to distinguish their products are claimed as trademarks. Where those designations appear in the book, and Manning Publications was aware of a trademark claim, the designations have been printed in initial caps or all caps. Recognizing the importance of preserving what has been written, it is Manning’s policy to have the books we publish printed on acid-free paper, and we exert our best efforts to that end. Recognizing also our responsibility to conserve the resources of our planet, Manning books are printed on paper that is at least 15 percent recycled and processed without the use of elemental chlorine. Manning Publications Co. 20 Baldwin Road PO Box 261 Shelter Island, NY 11964 Development editor: Cynthia Kane Technical proofreader: Jonathan Wakely Copyeditor: Linda Recktenwald Proofreader: Katie Tennant Typesetter: Dennis Dalinnik Cover designer: Marija Tudor ISBN: 9781933988771 Printed in the United States of America 1 2 3 4 5 6 7 8 9 10 – MAL – 18 17 16 15 14 13 12
    To Kim, Hugh, and Erin
    brief contents 1 ■ Hello, world of concurrency in C++! 1 2 ■ Managing threads 15 3 ■ Sharing data between threads 33 4 ■ Synchronizing concurrent operations 67 5 ■ The C++ memory model and operations on atomic types 103 6 ■ Designing lock-based concurrent data structures 148 7 ■ Designing lock-free concurrent data structures 180 8 ■ Designing concurrent code 224 9 ■ Advanced thread management 273 10 ■ Testing and debugging multithreaded applications 300 vii
    分享到：
    赞 收藏

    相关推荐

    资料库

    开发技术

    共收录19306份资料，累计14个分类，关注成员有19位，主要包括：Actionscript,Javascript,PHP,VB,Perl,Delphi,Python,C#,C,Java,C++,Web开发,硬件开发,其它

    热门标签

    Actionscript Javascript PHP VB Perl Delphi Python C# C Java C++ Web开发 硬件开发 其它

    最新资料