• Program:
  • A file containing machine language instructions, the entry-point address, data, symbol and relocation tables, and other information
• Process:
  • An instance of a program execution

• Flow of Control:
  • A sequence of control transfers (i.e., transitions between instructions/steps)
• Concurrent Flows:
  • Two flows, \(X\) and \(Y\), are said to running concurrently iff \(Y\) began after \(X\) began and before \(X\) finished or \(X\) began after \(Y\) began and before \(Y\) finished

• Threads:
  • A mechanism that allows for concurrent flows within a single process
• Advantages Over Multiple Processes:
  • The sharing information between threads is easy and fast
  • The creation of threads is faster than the creation of processes

• Text Segment:
  • All threads share the same program code (though they can be executing different parts)
• Data Segments:
  • All threads share the same uninitialized and initialized data segments

• Heap:
  • All threads share the same heap
• Stack:
  • Each thread has its own stack (in the stack space for the process)

• Shared:
  • Process ID, Process Group ID, and Session ID
  • Controlling Terminal
  • Credentials
  • Open File Descriptors
  • Record Locks
  • Signal Dispositions (making signals difficult to use)
  • Current Working Directory, Root Directory, etc...
  • Timers
  • Resource Limits
• Unique (a.k.a. Thread Context):
  • Thread ID
  • Signal Mask
  • errno and Condition Codes
  • Stack and Stack Pointer
  • Program Counter
  • General Purpose Register Values

#include <pthread.h>

Note:The new thread may start executing before pthread_create() returns.

• "Dropping Out":
  • The thread's start() function returns
• Process Termination:
  • Any thread calls exit()
  • The main thread returns from main()
• Forced Termination:
  • pthread_exit()

#include <pthread.h>

Note:The value pointed to by retval must not be on the thread's stack.

#include <pthread.h>

Note: Detaching a thread does not terminate it nor does it change the way in which a thread can/will be terminated.

#include <pthread.h>

Notes: (1) If thread has already terminated then pthread_join() will return immediately. (2) One must not call pthread_join() on a thread that has already been joined (since the ID may have been re-used).

• Remember:
  • One must either detach a thread or join with it (otherwise resources will be wasted)
• An Intentional Limitation:
  • One must join with a particular thread (i.e., one can't join with any undetached thread) since (unlike with processes) there is no thread hierarchy

• Compiling:
  • -pthread
• Linking:
  • -pthread

unixexamples/pthreads/messager.c

#include <pthread.h>
#include <stdio.h>    // For printf()
#include <stdlib.h>   // For exit()
#include <string.h>   // For strlen()
#include <unistd.h>   // For sleep() if needed

static void
*display(void *arg)
{
  char *s;
  void *result;

  // Demonstrate how to use the argument
  s = (char *)arg;               // Cast the void* as a char*
  printf("%s\n", s);             // Print

  // Demonstrate how to return
  result = (void *)(strlen(s)); // Cast the int as a void*
  return result;                // Return
}

int
main(void)
{
  char       *s;
  long       len;
  pthread_t  helper;
  void       *result;

  s = "Department of Computer Science";

  pthread_create(&helper, NULL, display, "JMU");
  printf("%s\n", s);

  pthread_join(helper, &result);
  len = (long)result;

  printf("Characters printed by the main   thread: %ld\n", (long)(strlen(s))); 
  printf("Characters printed by the helper thread: %ld\n", len);
  exit(0);
}
        

• Normally:
  • The function that a thread first executes is written exclusively for that purpose
• Sometimes:
  • The function is of more general applicability in which case it is convenient to write a wrapper function

unixexamples/pthreads/wrapper.c

#include <pthread.h>
#include <stdio.h>    // For printf()
#include <stdlib.h>   // For exit()
#include <string.h>   // For strlen()
#include <unistd.h>   // For sleep() if needed

// A function that is used for many purposes
long
display(char *s)
{
  printf("%s\n", s);
  return strlen(s);
}

// A wrapper for display() so that it can be executed in a thread
static void
*display_wrapper(void *arg)
{
  char  *s;
  long  result;

  s = (char *)arg;
  result = display(s);
  return (void *)result;
}

// The entry point of the program
int
main(void)
{
  char       *s;
  long       helper_len, main_len;
  pthread_t  helper;
  void       *result;

  s = "Department of Computer Science";

  pthread_create(&helper, NULL, display_wrapper, "JMU");

  main_len = display(s);

  pthread_join(helper, &result);
  helper_len = (long)result;

  printf("Characters printed by the main   thread: %ld\n", main_len); 
  printf("Characters printed by the helper thread: %ld\n", helper_len);
  exit(0);
}
        

unixexamples/pthreads/id.c

#include <pthread.h>
#include <stdio.h>    // For printf()
#include <stdlib.h>   // For exit()
#include <string.h>   // For strlen()
#include <unistd.h>   // For sleep() if needed

// A function that is used for many purposes
long
display(char *s)
{
  // Try adding calls to sleep() in various places
  printf("%s\n", s);
  printf("(Thread: %ld)\n", pthread_self());
  printf("\n\n");
  return strlen(s);
}

// A wrapper for display() so that it can be executed in a thread
static void
*display_wrapper(void *arg)
{
  char  *s;
  long  result;

  // Try adding calls to sleep() in various places
  s = (char *)arg;
  result = display(s);
  return (void *)result;
}

// The entry point of the program
int
main(void)
{
  char       *c, *d, *u;
  pthread_t  thread_c, thread_u;
  void       *result;

  d = "Department of Computer Science";
  c = "College of Integrated Science and Engineering";
  u = "James Madison University";
  
  display(d);
  pthread_create(&thread_c, NULL, display_wrapper, c);
  pthread_create(&thread_u, NULL, display_wrapper, u);


  pthread_join(thread_c, &result);
  pthread_join(thread_u, &result);
  exit(0);
}
        

#include <pthread.h>

The first call to pthread_once() modifies the value of the variable pointed to by control and then calls init(). Subsequent calls to pthread_once() then don't call init().