Scribd
Upload
202 views

C++ Threading: Tim Bailey

This document provides an introduction to C++ threading. It discusses that threads allow for multiple simultaneous paths of execution and shared memory. Good multi-threaded design focuses on communication between threads through passing data and avoiding race conditions and deadlocks. It also discusses techniques for safely accessing shared objects like using mutexes and condition variables to synchronize access between threads.

Uploaded by

Amarkant Avinash
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
202 views

C++ Threading: Tim Bailey

This document provides an introduction to C++ threading. It discusses that threads allow for multiple simultaneous paths of execution and shared memory. Good multi-threaded design focuses on communication between threads through passing data and avoiding race conditions and deadlocks. It also discusses techniques for safely accessing shared objects like using mutexes and condition variables to synchronize access between threads.

Uploaded by

Amarkant Avinash
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 14

C++ Threading

Tim Bailey

Tim Bailey C++ Exceptions


Introduction

• Very basic introduction to threads

• I do not discuss a thread API


• Easy to learn
• Use, eg., Boost.threads
• Standard thread API will be available soon
• The thread API is too low-level for thinking about
multi-threaded programming
• Your program will be complicated and error-prone

Tim Bailey C++ Exceptions


What are Threads?

• Multiple simultaneous paths of execution


• Single processor; pre-emptive time slicing
• Multiple processors; true parallel processing

• Shared address space


• Threads can access the same pointers and
objects

Tim Bailey C++ Exceptions


Why Threads?

• Some programs have a simpler, more natural


design with threads
• Some programs are more responsive

• “Why?” is not what this talk is about

Tim Bailey C++ Exceptions


Essence of Multi-Threaded Design

• Threading is about communication


• Passing/sharing data between threads
• Race conditions
• Deadlocks

• Good design makes multi-threaded code look


like single-threaded code
• Write code where you don’t have to think about
threading issues

Tim Bailey C++ Exceptions


Shared Objects and Race Conditions

• Writing to a shared state


• Non-atomic actions can cause tricky problems

• Complications, eg., cache


• See double checked locking debacle
http://www.cs.umd.edu/~pugh/java/memoryModel/
DoubleCheckedLocking.html

• Simple solution:
• Put mutexes around ALL accesses to shared
objects

Tim Bailey C++ Exceptions


Mutexes and Locks

• A mutex is a shared object associated with


shared data
• [see mutex.cpp, wrapping pthreads]
• A lock is a local object associated with a local
critical section
• Lock and unlock a mutex around a code block
that accesses the shared data
• Unlocking can be tricky
• Programmer forgetfulness
• Exceptions and resource release
• Solution RAII [see scopedlock.cpp]

Tim Bailey C++ Exceptions


Typical (Bad) Design

• Manual locking [see scopedlock.cpp]

• Problems
• Must remember to lock every time
• Must associate correct mutex with the data
• Threading is mingled throughout the code

• All code looks “multi-threaded” and is therefore


coupled and complicated
• Tricky thread-oriented debugging is not localised

Tim Bailey C++ Exceptions


Enforcing Shared Object Locking

• Monitor Object [see monitorobject.cpp]


• Non-intrusive internal locking
• Use to lock around individual member accesses
• Issue: multiple member accesses are not atomic

• Accessor Object [see sharedobject.cpp]


• Enforced external locking
• Use to lock around multiple member accesses

Tim Bailey C++ Exceptions


Condition Variables

• Condition variables
• Wait condition, allows a thread to block
• Signal from another thread unblocks waiting
thread; the two threads are synchronised
• [see condition.cpp, wrapping pthreads]

• Condition variables are an essential component


for building communication channels

Tim Bailey C++ Exceptions


Communication Channels

• Unidirectional channels
• Thread safety encapsulated within channel
• Permits localised thread debugging
• Interface looks like single-threaded code

• Channel has sender and receiver perspectives


• A thread sees only one endpoint
• Send endpoint, OR
• Receive endpoint
• Use proxy interfaces to enforce correct access
• [see channel.cpp]

Tim Bailey C++ Exceptions


Caveat: Memory Allocation

• Use of new invokes a global mutex


• Synchronises threads, degrades performance
• Worst if execution is parallel, not just time-sliced
• A problem for all heap-based allocation
• Advice:
• Consider using pre-allocated memory pools
• Use fixed-size channel buffers
• Avoid communicating objects whose
constructors allocate dynamic memory, since
• Blocking channel makes one copy
• Buffering channel makes two copies

Tim Bailey C++ Exceptions


What Remains?

• Lots...
• Read-write locks, try locks, spin locks, timeouts
• Re-entrant functions; avoid global and static variables
• Deadlock prevention/detection
• Thread priorities and scheduling
• Priority inversion
• Patterns
• Producer-Consumer
• Thread pools
• Active objects with Futures
• Publish-Subscriber
• Thread lifetimes
• Thread termination; graceful
• Detached, non-detached, joining
• Threads and exceptions
• Channel varieties
• Blocking, buffering, one-to-many, many-to-one
• Name services
• IDs of active threads, classes and objects
• Dynamically connecting/disconnecting channels at runtime
• Connection requests/notification

Tim Bailey C++ Exceptions


Conclusion

• Isolate thread-aware code


• Localise thread debugging to a few classes

• Majority of code communicates through high-level


interfaces
• Interfaces encapsulate thread safety
• Most code is written as single threaded (ie., thread-
oblivious)

• Simplicity is key

Tim Bailey C++ Exceptions

You might also like