• Threads.

  • Threading implementations: user v. kernel.

  • Thread states.

Review: Thread Transitions

A transition between two threads is called a context switch.

Review: CPU Limitations

What are problems with the CPU that the operating system tries to correct?
  • There is only one, and

  • it is way faster than other parts of the system.

Review: Batch Scheduling

What is batch scheduling?
  • Running jobs sequentially until completion.

What is the problem with batch scheduling?
  • Slow devices can idle the CPU.

Review: The Illusion of Concurrency

How does the operating system create the illusion of concurrency?
  • By rapidly switching the CPU between multiple running tasks.

Review: Seize the Day

How does the operating system ensure that it retains control over what threads are using the CPU?
  • By using a periodic timer to generate hardware interrupts.

Review: The Illusion of Concurrency

  • Timer interrupts mean that a running thread may be stopped at any time.

  • When the thread restarts we want it to appear that nothing has happened.

Review: Saving Thread State

What does thread state consist of?
  • Registers

  • Stack

Review: Context Switch Overhead

  • Context switches are not free, require executing many instructions and saving fair amount of state.

  • Context switching creates the cost to enter the kernel.

How does this affect the rate at which the hardware timer fires to allow the kernel to (potentially) switch between threads?
  • Can’t go too fast otherwise overhead starts to dominate!

Questions: CPU Limitations, Concurrency, Context Switching?


So what is a thread?
  • Registers

  • Stack

How are each of the following shared between threads or processes?
  • Registers

  • Stack

  • Memory

  • File descriptor table.


process 0
process 1
process 2
process 3
process 4

Why Use Threads?

  1. Threads can be a good way of thinking about applications that do multiple things "simultaneously."

  2. Threads may naturally encapsulate some data about a certain thing that the application is doing.

  3. Threads may help applications hide or parallelize delays caused by slow devices.

Threads v. Processes Part II

Good example from Wikipedia: multiple threads within a single process are like multiple cooks trying to prepare the same meal together.

  • Each one is doing one thing.

  • They are probably doing different things.

  • They all share the same recipe but may be looking at different parts of it.

  • They have private state but can communicate easily.

  • They must coordinate!


The OS corrupted

The cake

Aside: Threads v. Events

  • While threads are a reasonable way of thinking about concurrent programming, they are not the only way—​or even always the best way—​to make use of system resources.

  • Another approach is known as event-driven programming.

  • Anyone who has done JavaScript development or used frameworks like node.js has grown familiar with this programming model.

Events v. threads (over)simplified:
  • Threads can block, so we make use of the CPU by switching between threads!

  • Event handlers cannot block, so we can make use of the CPU by simply running events until completion.

Naturally Multithreaded Applications

Web server:
  • Use a separate thread to handle each incoming request.

Web browser:
  • Separate threads for each open tab.

  • When loading a page, separate threads to request and receive each unique part of the page.

Scientific applications:
  • Divide-and-conquer "embarrassingly parallelizable" data sets.

Why Not Processes?

  • IPC is more difficult because the kernel tries to protect processes from each other.

    • Inside a single process, anything goes!

  • State (what?) associated with processes doesn’t scale well.

Implementing Threads

Threads can be implemented in user space by unprivileged libraries.
  • This is the M:1 threading model, M user threads that look like 1 thread to the operating system kernel.

Threads can be implemented by the kernel directly.
  • This is the 1:1 threading model.

threadmodel base

threadmodel M1

threadmodel 11

Implementing Threads in User Space

How is this possible?
  • Doesn’t involve multiplexing between processes so no kernel privilege required!

How do I:
  • Save and restore context? This is just saving and restoring registers. The C library has an implementation called setjmp()/longjmp().

  • Preempt other threads? Use periodic signals delivered by the operating system to activate a user space thread scheduler.

Aside: setjmp()/longjmp() Wizardry

What will the following code do?

int main(int argc, void * argv) {
  int i, restored = 0;
  jump_buf saved;
    printf("Value of i is now %d\n", i);
    if (i == 5) {
      printf("OK, saving state...\n");
      if (setjmp(saved) == 0) {
        printf("Saved CPU state.\n");
      } else {
        printf("Restored CPU state.\n");
        restored = 1;
  if (!restored) {
    longjmp(saved, 1);
Value of i is now 0
Value of i is now 1
Value of i is now 2
Value of i is now 3
Value of i is now 4
Value of i is now 5
OK, saving state...
Saved CPU state.
Restored CPU state.
Value of i is now 6
Value of i is now 7
Value of i is now 8
Value of i is now 9
  • Use these tricks to impress your (new) friends!

  • (Or get rid of old ones…​)



Nailed the longjmp

Forgot the setjmp

Comparing Threading Implementations

M:1 (user space) threading

  • Threading operations are much faster because they do not have to cross the user/kernel boundary.

  • Thread state can be smaller.

  • Can’t use multiple cores!

  • Operating system may not schedule the application correctly because it doesn’t know about the fact that it contains more than one thread.

  • A single thread may block the entire process in the kernel when there are other threads that could run.

Comparing Threading Implementations

1:1 (kernel) threading

  • Scheduling might improve because kernel can schedule all threads in the process.

  • Context switch overhead for all threading operations.

Next: Thread Scheduling

  • We have discussed the mechanisms (context switching) used the multiplex the CPU…​

  • and the abstraction (threads).

  • We will start talking about scheduling next week: the policies the ensure that the multiplexing makes the best use of the available system resources.