1-1 © 2004 jmh associates. all rights reserved. windows application development chapter 7 windows...

1-1© 2004 JMH Associates. All rights reserved.

Windows Application DevelopmentWindows Application DevelopmentWindows Application DevelopmentWindows Application Development

Chapter 7

Windows Thread Management


Objectives and BenefitsObjectives and BenefitsObjectives and BenefitsObjectives and Benefits

Upon completion of this chapter, you will be able to: Describe Windows thread management Use threads in Windows applications Use threads with C library functions Build and execute threaded applications Describe scheduling and SMP operation


Threads: Benefits and RisksThreads: Benefits and RisksThreads: Benefits and RisksThreads: Benefits and Risks

Benefits Simpler program models Faster code – in many cases

Exploit multiple processors Exploit inherent application parallelism

Reliable, understandable, maintainable code Risks

Slower performance – in some cases Potential defects


ContentsContentsContentsContents

1. Process and Thread Overview

2. Thread Management

3. Waiting for Thread Termination

4. The C Library and Threads

5. Demonstration: Building a Threaded Application

6. Thread Priority, Scheduling, SMP Impact

7. Lab Exercise 7-1


1. Process and Thread Overview1. Process and Thread Overview1. Process and Thread Overview1. Process and Thread Overview

Threads in a process share data and code Each thread has its own stack for function calls Calling thread can pass an argument to a

thread at creation time This argument is on the stack

Each thread can allocate its own Thread Local Storage (TLS) indices and set TLS values


Process and Thread OverviewProcess and Thread OverviewProcess and Thread OverviewProcess and Thread Overview

Threads are scheduled and run independently The executive schedules threads Threads run asynchronously Threads can be preempted

Or restarted at any time


Processes and ThreadsProcesses and ThreadsProcesses and ThreadsProcesses and ThreadsProcess

Code

Global Variables

Process Heap

Process ResourcesOpen Files

Heaps…

Environment Block

...

Thread 1

Thread Local Storage

Stack

Thread N

Thread Local Storage

Stack


Read File B

Single-Threaded Program Multithreaded Program

Read File A

Read File B

Reading File B before

File A would give the same results

Read File A

Wait forThread 1 and

Thread 2 to finish

Merge datafrom both files

Thread 1

Thread 3

Thread 2

Thread 3

Merge datafrom both files

Threads Performing Parallel TasksThreads Performing Parallel TasksThreads Performing Parallel TasksThreads Performing Parallel Tasks


2. Thread Management2. Thread Management2. Thread Management2. Thread Management

Creating a Thread The Thread Function Thread Termination Thread Exit Codes Thread Identities Suspending and

Resuming Threads


Creating a Thread (1 of 6)Creating a Thread (1 of 6)Creating a Thread (1 of 6)Creating a Thread (1 of 6)

Specify the thread’s start address within the process’ code

Specify the stack size, and the stack consumes space within the process’ address space The stack cannot be expanded



Specify a pointer to an argument for the thread Can be nearly anything Interpreted by the thread itself

CreateThread returns a thread’s ID value and its handle A NULL handle value indicates failure



HANDLE CreateThread (

LPSECURITY_ATTRIBUTES lpsa,

DWORD cbStack,

LPTHREAD_START_ROUTINE lpStartAddr,

LPVOID lpvThreadParm,

DWORD dwCreate,

LPDWORD lpIDThread )



Parameters

lpsa Security attributes structure (use NULL)

cbStack Byte size for the new thread’s stack Use 0 to default to the primary thread’s stack

size (1 MB)



lpStartAddr Points to the function (within the calling

process) to be executed Accepts a single pointer argument and returns

a 32-bit DWORD exit code The thread can interpret the argument as a DWORD or a pointer

lpThreadParm The pointer passed as the thread argument



dwCreate If zero, the thread is immediately ready to run If CREATE_SUSPENDED, the new thread will be

in the suspended state, requiring a ResumeThread function call to move the thread to the ready state

lpIDThread Points to a DWORD that receives the new

thread’s identifier; NULL OK on W2000/NT


The Thread FunctionThe Thread FunctionThe Thread FunctionThe Thread Function

DWORD WINAPI MyThreadFunc (

PVOID pThParam )

{ . . .

ExitThread (ExitCode); /* OR */

return ExitCode;

}


Thread Termination (1 of 3)Thread Termination (1 of 3)Thread Termination (1 of 3)Thread Termination (1 of 3)

Threads are terminated by ExitProcess The process and all its threads terminate The exit code returned by the thread start

function same as the process exit code Or a thread can simply return with its exit code



ExitThread is the preferred technique The thread’s stack is deallocated on termination

VOID ExitThread (DWORD (dwExitCode)

When the last thread in a process terminates, so does the process itself



You can terminate a different thread with TerminateThread Dangerous: The thread’s stack and other

resources will not be deallocated Better to let the thread terminate itself

A thread will remain in the system until the last handle to it is closed (using CloseHandle) Then the thread will be deleted

Any other thread can retrieve the exit code


Thread Exit CodesThread Exit CodesThread Exit CodesThread Exit Codes

BOOL GetExitCodeThread (

HANDLE hThread,

LPDWORD lpdwExitCode )

lpdwExitCode Contains the thread’s exit code It could be STILL_ACTIVE


Thread Identities (1 of 2)Thread Identities (1 of 2)Thread Identities (1 of 2)Thread Identities (1 of 2)

A thread has a permanent “ThreadId” A thread is usually accessed by HANDLE An ID can be converted to a HANDLE


Thread Identities (2 of 2)Thread Identities (2 of 2)Thread Identities (2 of 2)Thread Identities (2 of 2)

HANDLE GetCurrentThread (VOID);

DWORD GetCurrentThreadId (VOID);

HANDLE OpenThread (

DWORD dwDesiredAccess,

BOOL InheritableHandle,

DWORD ThreadId );

/* >= Windows 2000 only */


Suspend & Resume Threads (1 of 2)Suspend & Resume Threads (1 of 2)Suspend & Resume Threads (1 of 2)Suspend & Resume Threads (1 of 2)

Every thread has a suspend count A thread can execute only if this count is zero

A thread can be created in the suspended state One thread can increment or decrement the

suspend count of another:

DWORD ResumeThread (HANDLE hThread)


Suspend & Resume Threads (2 of 2)Suspend & Resume Threads (2 of 2)Suspend & Resume Threads (2 of 2)Suspend & Resume Threads (2 of 2)

DWORD SuspendThread (HANDLE hThread)

Both functions return previous suspend count 0xFFFFFFFF indicates failure Useful in preventing “race conditions”

Do not allow threads to start until initialization is complete

Unsafe for general synchronization


3. Waiting for Thread Termination3. Waiting for Thread Termination3. Waiting for Thread Termination3. Waiting for Thread Termination

Wait for a thread to terminate using general purpose wait functions

WaitForSingleObject or WaitForMultipleObjects Using thread handles

The wait functions wait for the thread handle to become signaled Thread handle is signaled when thread

terminates


Waiting for Thread Termination (2 of 2)Waiting for Thread Termination (2 of 2)Waiting for Thread Termination (2 of 2)Waiting for Thread Termination (2 of 2)

ExitThread and TerminateThread set the object to the signaled state Releasing all other threads waiting on the

object ExitProcess sets the process’ state and all

its threads’ states to signaled


The Wait Functions (1 of 2)The Wait Functions (1 of 2)The Wait Functions (1 of 2)The Wait Functions (1 of 2)

DWORD WaitForSingleObject (

HANDLE hObject,

DWORD dwTimeOut )


The Wait Functions (2 of 2)The Wait Functions (2 of 2)The Wait Functions (2 of 2)The Wait Functions (2 of 2)

DWORD WaitForMultipleObjects (

DWORD cObjects,

LPHANDLE lphObjects,

BOOL fWaitAll,

DWORD dwTimeOut )

Return: The cause of the wait completion


Wait Options (1 of 2)Wait Options (1 of 2)Wait Options (1 of 2)Wait Options (1 of 2)

Specify either a single handle hObject

Or an array of cObjects referenced by lphObjects

cObjects should not exceed MAXIMUM_WAIT_OBJECTS - 64


Wait Options (2 of 2)Wait Options (2 of 2)Wait Options (2 of 2)Wait Options (2 of 2)

dwTimeOut is in milliseconds 0 means the function returns immediately after

testing the state of the specified objects Use INFINITE for no timeout

Wait forever for a thread to terminate

GetExitCodeThread Returns the thread exit code


Wait Function Return Values (1 of 3)Wait Function Return Values (1 of 3)Wait Function Return Values (1 of 3)Wait Function Return Values (1 of 3)

fWaitAll If TRUE, wait for all threads to terminate

Possible return values are: WAIT_OBJECT_0

The thread terminated (if calling WaitForMultipleObjects; fWaitAll set)



WAIT_OBJECT_0 + n

where 0 <= n < cObjects Subtract WAIT_OBJECT_0 from the return value to

determine which thread terminated when calling WaitForMultipleObjects with fWaitAll set

WAIT_TIMEOUT Timeout period elapsed



WAIT_ABANDONED Not possible with thread handles

WAIT_FAILED Call GetLastError for thread-specific error code


4. The C Library and Threads4. The C Library and Threads4. The C Library and Threads4. The C Library and Threads

Nearly all programs (and thread functions) use the C library

But the normal C library is not “thread safe”

The C function _beginthreadex has exactly the same parameters as CreateThread


Using Using _beginthreadex_beginthreadex (1 of 3) (1 of 3)Using Using _beginthreadex_beginthreadex (1 of 3) (1 of 3)

Cast the _beginthreadex return value to (HANDLE)

Use _endthreadex in place of ExitThread

#include <process.h>



Set the multithreaded environment as follows: #define _MT in every source file before <windows.h>

Link with LIBCMT.LIB Override the default library



Preferred method using Visual C++ From the menu bar:

Build Settings — C/C++ Tab Code Generation category Select a multithreaded run-time library


Ex: A Simple Boss ThreadEx: A Simple Boss ThreadEx: A Simple Boss ThreadEx: A Simple Boss Thread

HANDLE hWork[K];volatile LONGLONG WorkDone[K], iTh; /* !! */

. . .for (iTh = 0; iTh < K; iTh++) {

WorkDone[ith] = 0;hWork[iTh] = _beginthreadex (NULL, 0,WorkTh, (PVOID)&iTh, 0, NULL); /* BUG! */

}WaitForMultipleObjects (K, hWork, TRUE,

INFINITE);for (iTh = 0; iTh < K; iTh++)

printf (“Thread %d did %d workunits\n”,iTh, WorkDone[iTh]);


Ex: A Simple Worker ThreadEx: A Simple Worker ThreadEx: A Simple Worker ThreadEx: A Simple Worker Thread

DWORD WINAPI WorkTh (PVOID pThNum){

DWORD ThNum = (DWORD)(*pThNum);while (. . .) {

/* Perform work */WorkDone[ThNum]++;

}_endthreadex (0);

}


5. Demonstration: Building a Threaded 5. Demonstration: Building a Threaded ApplicationApplication

5. Demonstration: Building a Threaded 5. Demonstration: Building a Threaded ApplicationApplication

Using Visual C++ Ver. 6.0, 7.0


Demonstration Demonstration (1 of 2)(1 of 2)Demonstration Demonstration (1 of 2)(1 of 2)

Implement multithreaded word count programwcMT

Include the source code of wc with your application and execute it as a thread

Create one thread for each file to analyze Compare performance of single process, multi-

ple process, & multiple thread implementations If you use other libraries, build thread-safe

versions now!


DemonstrationDemonstration (2 of 2) (2 of 2)DemonstrationDemonstration (2 of 2) (2 of 2)

THIS IS A BOSS/WORKER SYSTEM Shows common thread management

techniques See picture on the next overhead

CHALLENGE: Also try at wcMTx.c and wcMTxx.c These contains some common bugs

What are the bug symptoms?


Boss/Worker Model for Boss/Worker Model for wcMTwcMTBoss/Worker Model for Boss/Worker Model for wcMTwcMT

Program Resources

Files

Workers

Thread K

Thread 1

Thread 0

main ()

Boss


6.Thread Priority and Scheduling6.Thread Priority and Scheduling6.Thread Priority and Scheduling6.Thread Priority and Scheduling

Windows kernels run the highest-priority thread that is ready for execution

4 priority classes set by CreateProcess IDLE_PRIORITY_CLASS (base priority 4) NORMAL_PRIORITY_CLASS (9 or 7) HIGH_PRIORITY_CLASS (13) REALTIME_PRIORITY_CLASS (24)

Windows XP extensions


Thread Priority (1 of 2)Thread Priority (1 of 2)Thread Priority (1 of 2)Thread Priority (1 of 2)

Change or determine a thread’s priority For itself For another process, security permitting

DWORD SetPriorityClass (

HANDLE hProcess, DWORD dwPriority)

DWORD GetPriorityClass (

HANDLE hProcess)


Thread Priority (2 of 2)Thread Priority (2 of 2)Thread Priority (2 of 2)Thread Priority (2 of 2)

Thread priorities set relative to base priority THREAD_PRIORITY_LOWEST THREAD_PRIORITY_BELOW_NORMAL THREAD_PRIORITY_NORMAL THREAD_PRIORITY_ABOVE_NORMAL THREAD_PRIORITY_HIGHEST


Process Priority CautionsProcess Priority CautionsProcess Priority CautionsProcess Priority Cautions

Use high thread priorities with caution Avoid real time priorities for user processes

User threads may preempt executive threads Assure fairness

All threads should run eventually Real time priorities may prevent fairness

“Priority inversion” “Thread starvation”


Thread States and Transitions (1 of 2)Thread States and Transitions (1 of 2)Thread States and Transitions (1 of 2)Thread States and Transitions (1 of 2)

A thread is running when it is on a processor SMP systems have multiple processors Intel Xeon provides single processor

multiprocessing - Hyperthreading The executive can place a running thread in

the wait state I/O operations wait wait for data transfer The thread is blocked or sleeping

A thread is ready if it could be running


Terminated

Running

Initialized

WaitingReady

Create a new thread

Time sliceis over

Goes toready queue

Wait, SleepOr any blocking call

Object issignaled

Thread Id is reused

Scheduled ona free processor

ExitThreadTerminateThread



The scheduler can place a ready thread on any available processor

The executive moves a running thread to the ready state if the thread’s time slice expires Sleep(0) moves a running thread to ready

The executive makes a waiting thread ready as soon as appropriate handles are signaled The thread wakes up



A thread can be suspended or resumed A thread is in the terminated state after it has

been terminated but there still open handles Other threads may interrogate the thread’s

state and exit code


SummarySummarySummarySummary

Threads allow concurrent processing Reducing overall system overhead Potentially simplifying programs

Single-threaded programs can be inefficient Managing concurrent and interacting tasks

Threads can streamline I/O-bound programs There are reliability and performance risks

Design and code carefully


8. Lab Exercise 7-18. Lab Exercise 7-18. Lab Exercise 7-18. Lab Exercise 7-1

Implement a multithreaded sort command, sortMT nTh FileName

Use the scheme shown on the next overhead nTh: number of threads If properly implemented, it will transparently

take advantage of SMP systems


sortMTsortMT Design DesignsortMTsortMT Design DesignArray

qsort

qsort

qsort

qsort

merge

merge

merge

Thread0

Thread1

Thread2

Thread3

for (i = 0; i < 4; i++) CreateThread ( )

Wait (Thread0)/* Array is Sorted */

wait (Thread3)

wait (Thread2)wait (Thread1)


Lab Exercise (cont’d)Lab Exercise (cont’d)Lab Exercise (cont’d)Lab Exercise (cont’d)

CAUTION: The lab solution requires that the number of

records in the file to be sorted be a multiple of the number of threads

The number of threads must be a power of two SUGGESTION:

Start with sortMTx.c, a buggy solution The correct solution is also provided


Extra Credit — Additional ExerciseExtra Credit — Additional ExerciseExtra Credit — Additional ExerciseExtra Credit — Additional Exercise

Remove the restrictions: The command form is sortMT nTh file nTh must be a power of two The number of records in file must be a

multiple of nTh What is the effect of multiple threads on per-

formance, even on a single processor system? Hint: Test with large files

1-1 © 2004 jmh associates. all rights reserved. windows application development chapter 7 windows...

Documents