C++0x并发实战：线程与并行编程指南

需积分: 43 146 浏览量更新于2024-07-28 收藏 2.13MB PDF 举报

"C++0x Concurrency in Action" 是一本关于C++0x（C++11）标准中引入的并发编程特性的详细指南。这本书涵盖了如何在C++程序中管理和同步线程，以及设计适用于并发环境的数据结构。书中讨论了C++内存模型、原子类型操作，并提供了高级线程管理策略，以及多线程应用的测试和调试方法。章节内容概述： 1. **第一章：介绍** - 引入并发编程的概念，解释为什么C++0x引入了这些特性，以及它们如何改进并行程序的设计和性能。 2. **第二章：管理线程** - 详述如何创建和管理线程，包括线程的启动、同步、通信和终止。可能涉及`std::thread`库的使用，以及线程的生命周期管理。 3. **第三章：共享数据** - 探讨线程间数据共享的挑战和解决方案，如使用`std::mutex`进行互斥访问，以及读写锁(`std::shared_mutex`, `std::upgrade_lock`)等。 4. **第四章：同步并发操作** - 介绍各种同步机制，如条件变量(`std::condition_variable`), 信号量(`std::semaphore`), 事件标志(`std::binary_semaphore`, `std::counting_semaphore`)等，以及它们在并发控制中的应用。 5. **第五章：C++内存模型和原子类型操作** - 解释C++内存模型的细节，以及如何使用原子类型(`std::atomic`)确保数据在多线程环境下的正确性。 6. **第六章：设计用于并发的数据结构I：基于锁的数据结构** - 讨论如何构建线程安全的数据结构，如线程安全的队列、栈等，以及使用互斥锁和其他同步原语来实现。 7. **第七章：设计用于并发的数据结构II：无锁并发数据结构** - 深入介绍无锁编程技术，以及如何实现无锁队列、栈等高效并发数据结构。 8. **第八章：设计并发代码** - 提供设计并发程序的最佳实践，包括避免竞态条件、死锁和优先级反转等问题。 9. **第九章：高级线程管理** - 讨论更复杂的线程调度和管理策略，如线程池和工作窃取算法。 10. **第十章：测试和调试多线程应用程序** - 介绍如何有效地测试并发代码，以及使用特定的调试工具和技巧来定位并修复并发问题。 11. **附录A：C++0x线程库使用的语言新特性** - 阐述C++11标准中与并发相关的语言新特性，如右值引用、Lambda表达式等，及其在并发编程中的作用。这本书对想要深入理解C++11及更高版本中并发特性的开发者来说是一份宝贵的资源，它提供了一套全面的方法来理解和解决并发编程中的复杂问题。通过实例和实践经验，读者可以学习到如何安全、高效地编写多线程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页未读，继续阅读

seacat_hello

粉丝: 7
资源: 1

C++0x并发实战：线程与并行编程指南

C++ Concurrency in Action_C++_action_

C++ Concurrency in Action 2nd.pdf

C++ Concurrency in Action, 2nd Edition（完整目录）.pdf.zip

c++ concurrency in action 2nd

c++ concurrency in action epub

C++ concurrency in action

c++ concurrency in action

concurrency in action, 2nd edition.pdf

迷宫游戏c++参考文献

describe the difference between parallelism and concurrency in embedded system

最新资源