C++并发编程实战：掌握TR2标准与高级同步技术

4星 · 超过85%的资源需积分: 35 195 浏览量更新于2024-07-26 收藏 1.55MB PDF 举报

"C++的并发行为"是一本由Anthony Williams撰写的专著，深入探讨了C++语言中的并发编程技术。随着C++标准和TR2（Technical Report 2）的发展，书中针对多线程编程提供了全面的指导，强调了如何利用这些新特性来简化和增强多线程应用的安全性。本书适合现有C++程序员，无论他们是否使用过平台特定的API进行多线程开发，或者对其他语言有经验，旨在帮助他们掌握C++并发编程的最佳实践。全书共分为十章，涵盖了广泛的并发主题： 1. **引言**：为读者介绍并发编程的基础概念和C++语言中并发的兴起，以及TR2为多线程带来的变化。 2. **管理线程**：讲解如何创建、启动和控制线程，包括线程生命周期的管理以及线程间的协作机制。 3. **共享数据**：讨论线程间数据访问的同步问题，包括读写锁、互斥锁等概念，以及避免数据竞争的重要性。 4. **同步并发操作**：阐述了同步原语如条件变量、信号量、事件等在并发编程中的应用，以及它们如何确保程序的正确执行顺序。 5. **C++内存模型和原子类型操作**：探讨内存模型对并发编程的影响，以及如何使用原子类型（atomic types）保证操作的可见性和一致性。 6. **设计并发数据结构I：基于锁的数据结构**：介绍如何设计支持并发访问的数据结构，包括读写锁和读写屏障等技术。 7. **设计并发数据结构II：无锁并发数据结构**：探索不依赖于锁的并发数据结构，如CAS（Compare-and-Swap）和乐观锁等高级技术。 8. **设计并发代码**：提供编写并发代码的策略和模式，如何处理异常、错误和死锁等问题。 9. **高级线程管理**：讨论线程池、任务队列等高级并发机制，以及如何优化线程调度和资源利用率。 10. **测试与调试多线程应用**：讲解如何有效地测试和调试复杂的并发系统，包括并发测试工具和调试技巧。附录A列举了C++语言中用于线程库的新特性和功能，这些内容有助于开发者了解并利用最新的C++语言特性进行高效并发编程。 "C++的并发行为"是一本实用的指南，为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页未读，继续阅读

huzhouhzy

粉丝: 83
资源: 1655

C++并发编程实战：掌握TR2标准与高级同步技术

C语言并发编程实战

C语言并发编程深度解析与实践

C++并发编程实战

操作系统哲学家就餐问题课程设计C语言.pdf

c++并发编程.rar_C 并发编程_C++并发编程_售票_售票系统_并发

《C++ 的并发行为》PDF]

C语言标准.英文.pdfC11.zip

(源码)基于C语言的高并发网络编程系统.zip

由C语言实现的单线程高并发的网络基础库.zip

双人游戏（C语言）.zip

最新资源