book

PThreads Programming

by Dick Buttlar, Jacqueline Farrell, Bradford Nichols

September 1996

Intermediate to advanced

286 pages

7h 11m

English

O'Reilly Media, Inc.

Read now

Unlock full access

OrganizationExample ProgramsFTPTypographical ConventionsAcknowledgments
What Are Pthreads?Potential ParallelismSpecifying Potential Parallelism in a Concurrent Programming EnvironmentUNIX Concurrent Programming: Multiple ProcessesCreating a new process: forkPthreads Concurrent Programming: Multiple ThreadsCreating a new thread: pthread_createThreads are peersParallel vs. Concurrent ProgrammingSynchronizationSharing Process ResourcesCommunicationSchedulingWho Am I? Who Are You?Terminating Thread ExecutionExit Status and Return ValuesPthreads Library Calls and ErrorsWhy Use Threads Over Processes?A Structured Programming EnvironmentChoosing Which Applications to Thread
Suitable Tasks for ThreadingModelsBoss/Worker ModelPeer ModelPipeline ModelBuffering Data Between ThreadsSome Common ProblemsPerformanceExample: An ATM ServerThe Serial ATM ServerHandling asynchronous events: blocking with selectHandling file I/O: blocking with read/writeThe Multithreaded ATM ServerModel: boss/worker modelThe boss threadDynamically detaching a threadA worker threadSynchronization: what’s neededFuture enhancementsExample: A Matrix Multiplication ProgramThe Serial Matrix-Multiply ProgramThe Multithreaded Matrix-Multiply ProgramPassing data to a new threadSynchronization in the matrix-multiply program
Selecting the Right Synchronization ToolMutex VariablesUsing MutexesError Detection and Return ValuesUsing pthread_mutex_trylockWhen Other Tools Are BetterSome Shortcomings of MutexesContention for a MutexExample: Using Mutexes in a Linked ListComplex Data Structures and Lock GranularityRequirements and Goals for SynchronizationAccess Patterns and GranularityLocking HierarchiesSharing a Mutex Among ProcessesCondition VariablesUsing a Mutex with a Condition VariableWhen Many Threads Are WaitingChecking the Condition on Wake Up: Spurious Wake UpsCondition Variable AttributesCondition Variables and UNIX SignalsCondition Variables and CancellationReader/Writer LocksSynchronization in the ATM ServerSynchronizing Access to Account DataLimiting the Number of Worker ThreadsSynchronizing a Server ShutdownThread PoolsAn ATM Server Example That Uses a Thread PoolInitializing a thread poolChecking for workAdding workDeleting a thread poolAdapting the atm_server_init and main routines
Setting Thread AttributesSetting a Thread’s Stack SizeSpecifying the Location of a Thread’s StackSetting a Thread’s Detached StateSetting Multiple AttributesDestroying a Thread Attribute ObjectThe pthread_once MechanismExample: The ATM Server’s Communication ModuleUsing a statically initialized mutexUsing the pthread_once mechanismKeys: Using Thread-Specific DataInitializing a Key: pthread_key_createAssociating Data with a KeyRetrieving Data from a KeyDestructorsCancellationThe Complication with CancellationCancelability Types and StatesCancellation Points: More on Deferred CancellationA Simple Cancellation ExampleThe bullet_proof thread: no effectThe ask_for_it thread: deferred cancellationThe sitting_duck thread: asynchronous cancellationCleanup StacksCancellation in the ATM ServerAborting a depositScheduling PthreadsScheduling Priority and PolicyScheduling Scope and Allocation DomainsRunnable and Blocked ThreadsScheduling PriorityScheduling PolicyUsing Priorities and PoliciesSetting Scheduling Policy and PriorityInheritanceScheduling in the ATM ServerMutex Scheduling AttributesPriority CeilingPriority InheritanceThe ATM Example and Priority Inversion
Threads and SignalsTraditional Signal ProcessingSending signals and waiting for signalsUsing a signal mask to block signalsSignal Processing in a Multithreaded WorldSynchronously generated signalsAsynchronously generated signalsPer-thread signal masksPer-process signal actionsPutting it all togetherThreads in Signal HandlersA Simple ExampleSome Signal IssuesHandling Signals in the ATM ExampleThreadsafe Library Functions and System CallsThreadsafe and Reentrant FunctionsExample of Thread-Unsafe and Threadsafe Versions of the Same FunctionFunctions That Return Pointers to Static DataLibrary Use of errnoThe Pthreads Standard Specifies Which Functions Must Be ThreadsafeAlternative interfaces for functions that return static dataAdditional routines for performance considerationsFile-locking functions for threadsWhere are the threadsafe functions?Using Thread-Unsafe Functions in a Multithreaded ProgramCancellation-Safe Library Functions and System CallsAsynchronous Cancellation-Safe FunctionsCancellation Points in System and Library CallsThread-Blocking Library Functions and System CallsThreads and Process ManagementCalling fork from a ThreadFork-handling stacksCalling exec from a ThreadProcess Exit and ThreadsMultiprocessor Memory Synchronization
Understanding Pthreads ImplementationTwo WorldsTwo Kinds of ThreadsWho’s Providing the Thread?User-space Pthreads implementationsKernel thread–based Pthreads implementationsTwo-level scheduler Pthreads implementations: the best of both worldsDebuggingDeadlockRace ConditionsEvent OrderingLess Is BetterTrace StatementsDebugger Support for ThreadsExample: Debugging the ATM ServerDebugging a deadlock caused by a missing unlockDebugging a race condition caused by a missing lockPerformanceThe Costs of Sharing Too Much—LockingThread OverheadThread context switchesSynchronization OverheadHow Do Your Threads Spend Their Time?Performance in the ATM Server ExamplePerformance depends on input workload: increasing clients and contentionPerformance depends on a good locking strategyPerformance depends on the type of work threads doKey performance issues between using threads and using processesConclusion

The Structure of a DCE ServerWhat Does the DCE Programmer Have to Do?Example: The ATM as a DCE Server
Detaching a ThreadMutex VariablesCondition VariablesThread AttributesThe pthread_once FunctionKeysCancellationSchedulingSignalsThreadsafe System InterfacesError ReportingSystem Interfaces and Cancellation-SafetyProcess-Blocking CallsProcess Management

Content preview from PThreads Programming

Chapter 2. Designing Threaded Programs

In this chapter:

So far you’ve seen only a couple of Pthreads calls, but you know enough about the programming model to start considering real design issues. In this chapter we’ll examine a number of broad questions. How much work is worth the overhead of creating a thread? How can I subdivide my program into threads? What relationship do the threads have to the functions in my program?

To give us a sample application worth threading, we’ll introduce an application that will take us through most of the book: a server for automatic teller machines (ATMs). We’ll try out our design ideas on this server.

Suitable Tasks for Threading

To find the places in your program where you can use threads, you essentially must look for the properties we identified in Chapter 1: potential parallelism, overlapping I/O, asynchronous events, and real-time scheduling. Whenever a task has one or more of these properties, consider running it in a thread. You can identify a task that is suitable for threading by applying to it the following criteria:

It is independent of other tasks.
Does the task use separate resources from other tasks? Does its execution depend on the results of other tasks? Do other tasks depend on its results? We want to maximize concurrency and minimize the need for synchronization. The more tasks ...