Intro to Threads

• Threads are lightweight processes
• The current standard, POSIX threads can work at different levels
  • If the kernel supports threads it is at the kernel level (linux)
  • Otherwise it is handeled at the process level.
• Threads are:
  • Up to 10 times faster to start than processes.
  • Share all global and heap values. (Shared communications)
  • But have a private stack.
• There is a list of shared things on page 619.
  • But MANY things are shared among threads.
• Threads use a number of datatypes
  • But the standard does not define these types.
  • "... and protable programs should treat them as opaque data. By this, we maen that a program should avoide any reliance on knowldge of the structure or components of a variable."
• reentrant functions
  • Some functions use memory provided outside of their stack.
  • These functions are not reentrant or thread safe.
  • Look at the man page for rand
    • int rand_r ( int * seed) is reentrant
    • int rand ( void) is not reentrant
    • The difference has to be a shared seed vs process stored seed.
  • Compiling with -pthread will
    • make some functions reentrent by default,
    • Include the pthread library
    • The latter is required.
    • Not the LDLIBS flag in the Makefile
• Creating a thread

  • #include <pthread.h>
    
    int pthread_create(pthread_t *restrict thread,
                       const pthread_attr_t *restrict attr,
                       void *(*start_routine)(void *),
                       void *restrict arg);
    
    Compile and link with -pthread.  

  • thread is the id of the thread that is created.
    • This is used by other thread controling calls.
    • BTW restrict says that the pionter is a "unique" pointer. No other object will access this pointer.
  • attr is a hints field we will discuss later.
  • start_routine is a function to call
    • It returns a void *
    • It takes a void * as a parameter.
    • This is a standard c style non-inheritance/non-generic programming trick.
    • We can pass it anything and get anything back.
    • We just have to cast things like crazy
  • arg is a pointer to the argument we are passing.
• Take a look at myPi.cpp
• Threads can exit in multiple ways. We will discuss these later.
• int pthread_join(pthread_t thread, void **retval);
  • Blocks until the specified thread exits.
  • retval is a pointer to a pointer, yuck
  • Undefined if mutiple threads try to join the same thread.
• Do we ant to do this or do we want pi2.cpp