深入理解C++并发编程

4星 · 超过85%的资源需积分: 0 43 浏览量更新于2024-07-25 收藏 2.13MB PDF 举报

"C++ Concurrency in Action 是一本关于C++多线程编程的书籍，涵盖了C++并发编程的各个方面，包括线程管理、数据共享、同步操作、内存模型、原子类型操作、锁基数据结构、无锁并发数据结构、并发代码设计、高级线程管理和多线程应用的测试与调试。" 本书旨在深入探讨C++中的并发概念和技术，帮助开发者在多核处理器环境下编写高效、可靠的并发程序。以下是对各章节主要内容的详细说明： 1. **第一章：介绍** - 引导读者进入并发编程的世界，介绍并发的基本概念和C++中支持并发编程的关键特性，为后续章节打下基础。 2. **第二章：管理线程** - 讨论如何创建和管理线程，包括线程的生命周期、线程间的通信以及如何在C++标准库中使用`std::thread`类进行线程操作。 3. **第三章：共享数据** - 阐述在并发环境中如何安全地共享数据，讨论各种数据竞争和死锁问题，以及避免这些问题的策略。 4. **第四章：同步并发操作** - 介绍互斥量、条件变量、信号量等同步原语，以及如何使用它们来协调并发线程间的操作，确保数据一致性。 5. **第五章：C++内存模型和原子类型操作** - 描述C++内存模型，解释其对并发编程的影响，以及如何使用原子类型（atomic types）确保数据在并发环境下的正确性。 6. **第六章：设计用于并发的数据结构I：锁基数据结构** - 探讨如何设计和实现基于锁的数据结构，如线程安全的队列、栈等，并分析其性能和局限性。 7. **第七章：设计用于并发的数据结构II：无锁并发数据结构** - 讨论无锁编程技术，介绍无锁队列、栈和其他高级数据结构的设计和实现，以及它们在性能上的优势和挑战。 8. **第八章：设计并发代码** - 提供指导原则和最佳实践，帮助开发者设计出可扩展且易于维护的并发代码。 9. **第九章：高级线程管理** - 深入讨论线程池、调度策略和其他高级线程管理技术，以优化并发程序的性能和资源利用。 10. **第十章：测试和调试多线程应用程序** - 探讨多线程程序的测试方法，包括并发错误的检测和调试技术，以及如何构建可靠的测试框架。 11. **附录A：C++线程库使用的语言新特性** - 对C++标准库中新增的并发特性进行详解，如智能指针、lambda表达式等在并发编程中的应用。通过学习这本书，读者将能够熟练掌握C++中的并发编程技术，解决多线程环境下可能出现的问题，提高程序的效率和可靠性。

©Manning Publications Co. Please post comments or corrections to the Author Online forum:

http://www.manning-sandbox.com/forum.jspa?forumID=437

The Standard C++ Library also provides higher level abstractions and facilities that

make writing multi-threaded code easier and less error-prone. Sometimes the use of these

facilities does comes with a performance cost due to the additional code that must be

executed. However, this performance cost does not necessarily imply a higher abstraction

penalty though: in general the cost is no higher than would be incurred by writing equivalent

functionality by hand, and the compiler may well inline much of the additional code anyway.

In some cases, the high level facilities provide additional functionality beyond what may

be required for a specific use. Most of the time this is not an issue: you don't pay for what

you don't use. On rare occasions this unused functionality will impact the performance of

other code. If you are aiming for performance, and the cost is too high, you may be better

off hand-crafting the desired functionality from lower-level facilities. In the vast majority of

cases, the additional complexity and chance of errors far outweighs the potential benefits

from a small performance gain. Even if profiling does demonstrate that the bottleneck is in

the C++ Standard Library facilities, it may be due to poor application design rather than a

poor library implementation. For example, if too many threads are competing for a mutex it

will impact the performance significantly. Rather than trying to shave a small fraction of time

off the mutex operations, it would probably be more beneficial to restructure the application

so that there was less contention on the mutex. This sort of issue is covered in chapter 8.

In those very rare cases where the C++ Standard Library does not provide the

performance or behaviour required, it might be necessary to use platform specific facilities.

1.3.4 Platform-Specific Facilities

Whilst the C++ Thread Library provides reasonably comprehensive facilities for multi-

threading and concurrency, on any given platform there will be platform-specific facilities

that go beyond what is offered. In order to gain easy access to those facilities without giving

up the benefits of using the Standard C++ thread library, the types in the C++ Thread

Library may offer a

native_handle() member function which allows the underlying

implementation to be directly manipulated using a platform-specific API. By its very nature,

any operations performed using the

native_handle() are entirely platform dependent, and

out of the scope of this book (and the C++ Standard Library itself).

Of course, before even considering using platform-specific facilities, it's important to

understand what the Standard library provides, so let's get started with an example.

1.4 Getting Started

OK, so you've got a nice shiny C++09-compatible compiler. What next? What does a multi-

threaded C++ program look like? It looks pretty much like any other C++ program, with the

usual mix of variables, classes and functions. The only real distinction is that some functions

Licensed to JEROME RAYMOND <pedbro@gmail.com>

Download at WoweBook.Com

©Manning Publications Co. Please post comments or corrections to the Author Online forum:

http://www.manning-sandbox.com/forum.jspa?forumID=437

execution begins. For the initial thread in an application, this is main(), but for every other

thread it is specified in the constructor of a

std::thread object — in this case, the

std::thread object named t (#3) has the new function hello() as its initial function.

This is the next difference — rather than just writing directly to standard output, or

calling

hello() from main(), this program launches a whole new thread to do it, bringing

the thread count to two: the initial thread that starts at

main(), and the new thread that

starts at

hello().

After the new thread has been launched (#3), the initial thread continues execution. If it

didn't wait for the new thread to finish, it would merrily continue to the end of

main(), and

thus end the program — possibly before the new thread had had a chance to run. This is why

the call to

join() is there (#4) — as described in chapter 2, this causes the calling thread

(in

main()) to wait for the thread associated with the std::thread object — in this case, t.

If this seems like a lot of work to go to just to write a message to standard output, it is

— as described in section 1.2.3 above, it is generally not worth the effort to use multiple

threads for such a simple task, especially if the initial thread has nothing to do in the mean

time. Later in the book, we will work through examples which show scenarios where there is

a clear gain to using multiple threads.

1.5 Summary

In this chapter, we've covered what is meant by concurrency and multi-threading, and why

we would choose to use it (or not) in our applications. We've also covered the history of

multi-threading in C++ from the complete lack of support in the 1998 Standard, through

various platform-specific extensions to proper multi-threading support in the new C++

Standard, C++0x. This support is coming just in time to allow programmers to take

advantage of the greater hardware concurrency becoming available with newer CPUs, as chip

manufacturers choose add more processing power in the form of multiple cores which allow

more tasks to be executed concurrently, rather than increasing the execution speed of a

single core.

We've also seen quite how simple to use the classes and functions from the C++

Standard Library can be, in the examples from section 1.4. In C++, using multiple threads is

not complicated in and of itself — the complexity lies in designing the code so that it behaves

as intended.

After the taster examples of section 1.4, it's time for something with a bit more

substance. In chapter 2 we'll look at the classes and functions available for managing

threads.

Licensed to JEROME RAYMOND <pedbro@gmail.com>

Download at WoweBook.Com

©Manning Publications Co. Please post comments or corrections to the Author Online forum:

http://www.manning-sandbox.com/forum.jspa?forumID=437

Managing Threads

OK, so you've decided to use concurrency for your application. In particular, you've decided

to use multiple threads. What now? How do you launch these threads, how do you check that

they've finished, and how do you keep tabs on them? The C++ Standard Library makes most

thread management tasks relatively easy, with just about everything managed through the

std::thread object associated with a given thread, as you'll see. For those tasks that aren't

so straightforward, the library provides the flexibility to build what you need from the basic

building blocks.

In this chapter, we'll start by covering the basics: launching a thread, waiting for it to

finish, or running it in the background. We'll then proceed to look at passing additional

parameters to the thread function when it is launched, and how to transfer ownership of a

thread from one

std::thread object to another. Finally, we'll look at choosing the number

of threads to use, and identifying particular threads.

2.1 Basic Thread Management

Every C++ program has at least one thread, which is started by the C++ runtime: the

thread running

main(). Your program can then launch additional threads which have

another function as the entry point. These threads then run concurrently with each other and

with the initial thread. Just as the program exits when the program returns from

main(),

when the specified entry point function returns, the thread is finished. As we'll see, if you

have a

std::thread object for a thread, you can wait for it to finish, but first we have to

start it so let's look at launching threads.

2.1.1 Launching a Thread

As we saw in chapter 1, threads are started by constructing a std::thread object that

specifies the task to run on that thread. In the simplest case, that task is just a plain,

ordinary

void-returning function that takes no parameters. This function runs on its own

Licensed to JEROME RAYMOND <pedbro@gmail.com>

Download at WoweBook.Com

http://www.manning-sandbox.com/forum.jspa?forumID=437

thread until it returns, and then the thread stops. At the other extreme, the task could be a

function object that takes additional parameters, and performs a series of independent

operations that are specified through some kind of messaging system whilst it is running,

and the thread only stops when it is signalled to do so, again via some kind of messaging

system. It doesn't matter what the thread is going to do, or where it's launched from, but

starting a thread using the C++ thread library always boils down to constructing a

std::thread object:

void do_some_work();

std::thread my_thread(do_some_work);

This is just about as simple as it gets. Of course, as with much of the Standard C++ library,

you can pass an instance of a class with a function call operator to the

std::thread

constructor instead:

class background_task

{

public:

void operator()() const

{

do_something();

do_something_else();

}

};

background_task f;

std::thread my_thread(f);

In this case, the supplied function object is copied into the storage belonging to the newly-

created thread of execution, and invoked from there. It is therefore essential that the copy

behaves equivalently to the original, or the result may not be what is expected.

Since the callable object supplied to the constructor is copied into the thread, the

original object can be destroyed immediately. However, if the object contains any pointers or

references, it is important to ensure that those pointers and references remain valid as long

as they may be accessed from the new thread, otherwise undefined behaviour will result. In

particular, it is a bad idea to create a thread within a function that has access to the local

variables in that function, unless the thread is guaranteed to finish before the function exits.

Listing 2.1 shows an example of a just such a problematic function.

Listing 2.1: A function that returns whilst a thread still has access to local variables

struct func

{

int& i;

func(int& i_):i(i_){}

void operator()()

Licensed to JEROME RAYMOND <pedbro@gmail.com>

Download at WoweBook.Com

剩余336页未读，继续阅读

liuxuejiang158

粉丝: 545
资源: 112

深入理解C++并发编程

C++ Concurrency in Action 2nd.pdf

C++ Concurrency In Action

c++ concurrency in action

C++ concurrency in action

c++ concurrency in action笔记

C++ concurrency in action kindle

c++ concurrency in action 2012

C++ Concurrency in Action 原版

c++ concurrency in action epub

c++ concurrency in action 2nd

最新资源