One of the key advantages of threading is the capability of tasks to share data and other resources, such as open files, network connections, and the user interface. But concurrency creates some uncertainty over when each task reads or writes resources, leading to the need for mutual exclusion.

The Threading Building Blocks algorithms encourage code that does not make extensive use of concurrent accesses to the same objects. Threading Building Blocks also provides concurrent containers, which greatly reduce the difficulty of using key data structures concurrently.

Explicit synchronization is still sometimes necessary, but you are encouraged to exploit implicit task synchronization where possible. For occasions when you need to provide your own locking, the mutual exclusions methods described in this chapter prove to be much better in common multithreading applications than other synchronization objects (such as Windows synchronization objects).

Chapter 2 introduced mutual exclusion and locks, explained deadlock and race conditions, and pointed out what to look for to have thread-safe programs. If you are unfamiliar with these terms, you should read the appropriate sections in Chapter 2. This chapter describes atomic operations, which are preferred, and locks. When it is not possible to use an atomic operation, locks need to be used to obtain mutual exclusion.

Because you program in terms of tasks, not threads, you will probably think of mutual exclusion of tasks. This leads to task-safe code, but because it is normally referred to as thread-safe code, we will use that name as well. Otherwise, all discussion of mutual exclusion will be in terms of tasks. Mutual exclusion of tasks will lead to mutual exclusion of the corresponding threads upon which Threading Building Blocks maps your tasks.