1. Threads

2. Progressing With Parallel Processing
eWeek (09/18/06) Vol. 23, No. 37, P. D5
Multithreading skills are becoming essential as parallel processing hardware proliferates, and developers ignore at their own peril indications of this trend such as Intel's investments in college curriculum and resources for multithread development training. The Java programming language supports the expression of concurrency in the same language developers are already employing for application logic, while powerful abstractions for C++ are also offered by concurrency toolkits and frameworks. Being able to count the threads developers are using on the fingers of one hand is folly, according to principal author of "Java Concurrency in Practice" Brian Goetz. He and his five co-authors note that "The need for thread safety is contagious," because "frameworks may create threads on your behalf, and code called from these threads must be thread-safe." It is the authors' contention that developers should never lose sight of the application state and avoid becoming overwhelmed by threading mechanisms. Developers must also keep in mind that careless habits that are acceptable in single-thread environments may be exposed in multithread environments.

3. 2.2 Threads Process: address space + code execution
There is no law that states that a process cannot have more than one “line” of execution.
Threads: single address space + many threads of execution
Shared global variables, stack address space, open files, signals, child processes, etc.

4. Threads Process – used to group resources together
Threads – entities scheduled for execution on CPU
Sometimes called lightweight processes
Multithreading – multiple threads in the same process

5. 2 3

8. Thread functions Create threads: #include <pthread.h>
int pthread_create (
pthread_t* thread,
pthread_attr_t* attr,
void* (*start_routine)(void *),
void* arg );

9. Thread termination void pthread_exit ( void* retval );
int pthread_cancel ( pthread_t thread );

10. Why threads? Easier to create a thread than a process Share resources
Compute and I/O within a single process on a single processor can be overlapped
Compute and compute within a single process on a multiprocessor can be overlapped

11. Example: word processor
Multiple threads:
User interaction
Document reformatting
Automatic saving/backups
Alternative is everything else stops when (2) or (3) occurs.

12. Example: web server Dispatcher – handles incoming requests
Workers – performs request
Checks cache
Reads from disk if necessary
Adds to cache

13. Threads and alternatives
Threads retain the simple sequential, blocking model while allowing for parallelism.
The single threaded server retains the simple sequential, block model but performance suffers (no parallelism).
Finite state machine = each computation has a saved state and there exists some set of events that can occur to change the state
High performance through parallelism
Uses nonblocking calls and interrupts (not simple)
May be in user space or kernel.

14. Threads Thread types: (also popup) Implementations: Detached Joinable
User space
Kernel
Hybrid

15. Pitfall: global variables
#include <stdio.h>
bool err = false;
void* t1 ( void* p ) { …
err = true;
if (err) puts( “hello” ); //may never get here! }
void* t2 ( void* p ) {
err = false;
int main ( int argc, char* argv[] ) {
if (err) puts( “something bad happened.” );
Pitfall: global variables

16. Pitfalls: global variables

17. Pitfall: global variables
Solution: don’t use ‘em.
Solution: create thread-wide globals (using your own libraries)
Solution: (other mechanisms that we will explore in the future)

18. Other pitfalls Libraries may not be reentrant
Solution: rewrite the library
Solution: wrap each library call with a wrapper
Signals, alarms, and I/O may not be thread specific.

19. Other pthread functions
int thread_yield ( );
int pthread_join (
pthread_t th,
void** thread_return );
Many, many others

20. Multithreaded example 1

21. /*
file: pt1.cpp
date: sep-2005
author: george j. grevera, ph.d.
compile: g++ -o pt1.exe pt1.cpp -lpthread -lm
desc.: shell of a multithreaded app */
#include <math.h>
#include <pthread.h>
#include <stdio.h>
//global variables
const int N = 10; //max number of threads
pthread_t thread[N]; //for thread id storage //

22. //----------------------------------------------------------------------
//program execution begins here.
int main ( const int argc, const char* const argv[] ) {
//create N threads
for (int i=0; i<N; i++) {
pthread_create( &thread[i], 0, start_routine, (void*)i );
printf( "main: thread %d created. \n", thread[i] ); }
//wait for the N threads to finish
void* v;
printf( "main: waiting \n" );
pthread_join( thread[i], &v );
printf( "main: returning \n" );
return 0;

23. //----------------------------------------------------------------------
//example worker thread function. this function does a lot of "work"
// (i.e., computation).
double doWork ( const int whoAmI ) {
double sum = 0.0;
for (int i=0; i< ; i++) {
sum += sin( i ) * cos( i ); }
return sum;
//main thread function
void* start_routine ( void* p ) {
int whoAmI = (int)p;
printf( "%d processing \n", whoAmI );
doWork( whoAmI );
printf( "%d exit \n", whoAmI );
return 0;

24. /*
file: pt1.cpp
date: sep-2005
author: george j. grevera, ph.d.
compile: g++ -o pt1.exe pt1.cpp -lpthread -lm
desc.: shell of a multithreaded app */
#include <math.h>
#include <pthread.h>
#include <stdio.h>
//global variables
const int N = 10; //max number of threads
pthread_t thread[N]; //for thread id storage //
//example worker thread function. this function does a lot of "work"
// (i.e., computation).
double doWork ( const int whoAmI ) {
double sum = 0.0;
for (int i=0; i< ; i++) {
sum += sin( i ) * cos( i ); }
return sum;
//main thread function
void* start_routine ( void* p ) {
int whoAmI = (int)p;
printf( "%d processing \n", whoAmI );
doWork( whoAmI );
printf( "%d exit \n", whoAmI );
return 0;
//program execution begins here.
int main ( const int argc, const char* const argv[] ) {
//create N threads
for (int i=0; i<N; i++) {
pthread_create( &thread[i], 0, start_routine, (void*)i );
printf( "main: thread %d created. \n", thread[i] );
//wait for the N threads to finish
void* v;
printf( "main: waiting \n" );
pthread_join( thread[i], &v );
printf( "main: returning \n" );

25. Multithreading discussion
pthread_create only allows a single parameter to be passed to the thread
pthread_join only allows a single parameter to be returned from a thread
How can we pass and return many parameters?

26. Multithreading: advanced topic
We know that process memory is shared among all threads.
We know that the stack is part of the process memory.
Therefore the stack is part of the memory that is shared among the threads.
How can we demonstrate that the stack is shared among threads?

27. From where are local variables allocated?/*
This program demonstrates that, although stack variables are not
shared among threads, stack memory (_all_ process memory) is indeed
shared by threads.
g++ -o sharedStack.exe sharedStack.cpp -lpthread -lm -lrt */
#include <iostream>
#include <math.h>
#include <pthread.h>
#include <sched.h>
#include <unistd.h>
using namespace std;
const int N = 2; //max number of threads
//this will be a pointer to a local variable in thread 0.
static int* whoAmIPointer = NULL; //
From where are local variables allocated?

28. //----------------------------------------------------------------------
int main ( const int argc, const char* const argv[] ) {
pthread_t thread[::N]; //for thread id storage
//create N threads
for (int i=0; i< ::N; i++) {
pthread_create( &thread[i], 0, start_routine, (void*)i );
cout << "main: thread " << i << " created with id=" << thread[i]
<< endl; }
//wait for the N threads to finish
void* v;
cout << "main: wait" << endl;
pthread_join( thread[i], &v );
cout << "main: returning" << endl;
return 0;
Nothing new here.

29. //----------------------------------------------------------------------
void* start_routine ( void* p ) {
int whoAmI = (int)p;
int whoAmICopy = whoAmI;
cout << whoAmI << " processing" << endl;
if (whoAmI==0) { //is this thread 0?
//make the global var point to my local var
::whoAmIPointer = &whoAmI;
sched_yield();
sleep( 5 );
} else {
//this is not thread 0 so wait until thread 0 sets the global var
// that points to thread 0's local var.
while (::whoAmIPointer==NULL) { }
//change thread 0's local var
*::whoAmIPointer = 92;
if (whoAmI!=whoAmICopy) {
cout << "Hey! Wait a minute! Somebody changed who I am from "
<< whoAmICopy << " to " << whoAmI << "!" << endl;
cout << whoAmI << " done" << endl
<< whoAmI << " exit" << endl;
return 0;
What does :: mean in C++?

30. //----------------------------------------------------------------------
void* start_routine ( void* p ) {
int whoAmI = (int)p;
int whoAmICopy = whoAmI;
cout << whoAmI << " processing" << endl;
if (whoAmI==0) { //is this thread 0?
//make the global var point to my local var
::whoAmIPointer = &whoAmI;
sched_yield();
sleep( 5 );
} else {
//this is not thread 0 so wait until thread 0 sets the global var
// that points to thread 0's local var.
while (::whoAmIPointer==NULL) { }
//change thread 0's local var
*::whoAmIPointer = 92;
if (whoAmI!=whoAmICopy) {
cout << "Hey! Wait a minute! Somebody changed who I am from "
<< whoAmICopy << " to " << whoAmI << "!" << endl;
cout << whoAmI << " done" << endl
<< whoAmI << " exit" << endl;
return 0;
What does :: mean in C++?
:: is the C++ scope resolution operator. In this case, it refers to a global variable.

31. //----------------------------------------------------------------------
void* start_routine ( void* p ) {
int whoAmI = (int)p;
int whoAmICopy = whoAmI;
cout << whoAmI << " processing" << endl;
if (whoAmI==0) { //is this thread 0?
//make the global var point to my local var
::whoAmIPointer = &whoAmI;
sched_yield();
sleep( 5 );
} else {
//this is not thread 0 so wait until thread 0 sets the global var
// that points to thread 0's local var.
while (::whoAmIPointer==NULL) { }
//change thread 0's local var
*::whoAmIPointer = 92;
if (whoAmI!=whoAmICopy) {
cout << "Hey! Wait a minute! Somebody changed who I am from "
<< whoAmICopy << " to " << whoAmI << "!" << endl;
cout << whoAmI << " done" << endl
<< whoAmI << " exit" << endl;
return 0;

32. //----------------------------------------------------------------------
void* start_routine ( void* p ) {
int whoAmI = (int)p;
int whoAmICopy = whoAmI;
cout << whoAmI << " processing" << endl;
if (whoAmI==0) { //is this thread 0?
//make the global var point to my local var
::whoAmIPointer = &whoAmI;
sched_yield();
sleep( 5 );
} else {
//this is not thread 0 so wait until thread 0 sets the global var
// that points to thread 0's local var.
while (::whoAmIPointer==NULL) { }
//change thread 0's local var
*::whoAmIPointer = 92;
if (whoAmI!=whoAmICopy) {
cout << "Hey! Wait a minute! Somebody changed who I am from "
<< whoAmICopy << " to " << whoAmI << "!" << endl;
cout << whoAmI << " done" << endl
<< whoAmI << " exit" << endl;
return 0;

33. //----------------------------------------------------------------------
void* start_routine ( void* p ) {
int whoAmI = (int)p;
int whoAmICopy = whoAmI;
cout << whoAmI << " processing" << endl;
if (whoAmI==0) { //is this thread 0?
//make the global var point to my local var
::whoAmIPointer = &whoAmI;
sched_yield();
sleep( 5 );
} else {
//this is not thread 0 so wait until thread 0 sets the global var
// that points to thread 0's local var.
while (::whoAmIPointer==NULL) { }
//change thread 0's local var
*::whoAmIPointer = 92;
if (whoAmI!=whoAmICopy) {
cout << "Hey! Wait a minute! Somebody changed who I am from "
<< whoAmICopy << " to " << whoAmI << "!" << endl;
cout << whoAmI << " done" << endl
<< whoAmI << " exit" << endl;
return 0;

34. //----------------------------------------------------------------------
void* start_routine ( void* p ) {
int whoAmI = (int)p;
int whoAmICopy = whoAmI;
cout << whoAmI << " processing" << endl;
if (whoAmI==0) { //is this thread 0?
//make the global var point to my local var
::whoAmIPointer = &whoAmI;
sched_yield();
sleep( 5 );
} else {
//this is not thread 0 so wait until thread 0 sets the global var
// that points to thread 0's local var.
while (::whoAmIPointer==NULL) { }
//change thread 0's local var
*::whoAmIPointer = 92;
if (whoAmI!=whoAmICopy) {
cout << "Hey! Wait a minute! Somebody changed who I am from "
<< whoAmICopy << " to " << whoAmI << "!" << endl;
cout << whoAmI << " done" << endl
<< whoAmI << " exit" << endl;
return 0;

35. How could this ever be true (if threads didn’t share stack memory)?//
void* start_routine ( void* p ) {
int whoAmI = (int)p;
int whoAmICopy = whoAmI;
cout << whoAmI << " processing" << endl;
if (whoAmI==0) { //is this thread 0?
//make the global var point to my local var
::whoAmIPointer = &whoAmI;
sched_yield();
sleep( 5 );
} else {
//this is not thread 0 so wait until thread 0 sets the global var
// that points to thread 0's local var.
while (::whoAmIPointer==NULL) { }
//change thread 0's local var
*::whoAmIPointer = 92;
if (whoAmI!=whoAmICopy) {
cout << "Hey! Wait a minute! Somebody changed who I am from "
<< whoAmICopy << " to " << whoAmI << "!" << endl;
cout << whoAmI << " done" << endl
<< whoAmI << " exit" << endl;
return 0;
How could this ever be true (if threads didn’t share stack memory)?

36. /*
This program demonstrates that, although stack variables are not
shared among threads, stack memory (_all_ process memory) is indeed
shared by threads.
g++ -o sharedStack.exe sharedStack.cpp -lpthread -lm -lrt */
#include <iostream>
#include <math.h>
#include <pthread.h>
#include <sched.h>
#include <unistd.h>
using namespace std;
const int N = 2; //max number of threads
//this will be a pointer to a local variable in thread 0.
static int* whoAmIPointer = NULL; //
void* start_routine ( void* p ) {
int whoAmI = (int)p;
int whoAmICopy = whoAmI;
cout << whoAmI << " processing" << endl;
if (whoAmI==0) { //is this thread 0?
//make the global var point to my local var
::whoAmIPointer = &whoAmI;
sched_yield();
sleep( 5 );
} else {
//this is not thread 0 so wait until thread 0 sets the global var
// that points to thread 0's local var.
while (::whoAmIPointer==NULL) { }
//change thread 0's local var
*::whoAmIPointer = 92;
if (whoAmI!=whoAmICopy) {
cout << "Hey! Wait a minute! Somebody changed who I am from "
<< whoAmICopy << " to " << whoAmI << "!" << endl;
cout << whoAmI << " done" << endl
<< whoAmI << " exit" << endl;
return 0;
int main ( const int argc, const char* const argv[] ) {
pthread_t thread[::N]; //for thread id storage
//create N threads
for (int i=0; i< ::N; i++) {
pthread_create( &thread[i], 0, start_routine, (void*)i );
cout << "main: thread " << i << " created with id=" << thread[i]
<< endl;
//wait for the N threads to finish
void* v;
cout << "main: wait" << endl;
pthread_join( thread[i], &v );
cout << "main: returning" << endl;

37. Win32 thread functions CreateThread ExitThread TerminateThread
WaitForSingleObject
GetExitCodeThread

38. Win32 threads & fibers Fibers (in win32 – not available in Linux)
A lightweight thread
Owned by thread
Threads are preemptively scheduled
Fibers are not preemptively scheduled
When thread is preempted, so is fiber
When thread is resumed, so is fiber
May be scheduled by owning thread