C++并发编程实战

需积分: 35 22 浏览量更新于2024-07-21 收藏 1.55MB PDF 举报

"C.的并发行为 - C.Concurrency.in.Action.pdf" 并发行为是计算机科学中的一个关键主题，尤其是在多核处理器和多线程系统日益普及的今天。在C语言环境中，理解和掌握并发行为至关重要，因为它涉及到如何有效地利用硬件资源，提高程序的执行效率。本书"C.的并发行为"似乎深入探讨了C语言中与并发相关的概念和技术。在第一章"介绍"中，作者可能概述了并发编程的基本概念，包括为什么我们需要并发以及它在现代计算中的重要性。他们可能还讨论了C语言在处理并发时的优势和挑战。第二章"管理线程"可能涵盖了创建、管理和销毁线程的机制，以及如何控制线程的优先级和同步。这可能包括使用POSIX线程库（pthread）或其他C语言支持的线程接口。第三章"共享数据"可能涉及在多线程环境下如何安全地访问和修改共享变量。作者可能会讲解到临界区、互斥量、信号量等并发控制工具，以防止数据竞争和死锁等问题。第四章"同步并发操作"可能进一步深入到高级同步技术，如条件变量、读写锁和屏障，这些都用于协调多个线程之间的操作。第五章"C++内存模型和原子类型操作"可能专注于C++11及更高版本中引入的内存模型，解释其如何确保跨线程的正确性。原子类型的操作使得程序员可以编写出无锁数据结构和算法，从而实现高效并发。第六章和第七章分别讨论了"基于锁的数据结构"和"无锁并发数据结构"的设计。前者可能涵盖使用锁来保护数据结构的常见方法，而后者则可能介绍无锁编程技术，如CAS（Compare and Swap）操作，它们可以提高并发性能但同时也更复杂。第八章"设计并发代码"可能提供了一些最佳实践和设计模式，帮助开发者编写出可维护且并发友好的代码。第九章"高层次的线程管理"可能涵盖了线程池、调度策略和线程局部存储等高级主题，这些都是优化并发应用程序的关键。第十章"测试和调试多线程应用程序"强调了并发软件的调试难度，并提供了识别和修复并发问题的策略和工具。最后，附录A可能总结了C++语言中线程库所用的新特性，包括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页未读，继续阅读

ttianlirui

粉丝: 0
资源: 1

C++并发编程实战

性能之并发用户数的计算.doc

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

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

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

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

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

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

C语言并发编程实战

C语言中的并发实战

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

最新资源