Thread

1. Definition

• Idea: allow multiple thread of execution within the same process environment, to a large degree independent of each other.
• Multiple threads running in parallel in one process is analogous to having multiple processes running in parallel in one computer.
• Multiple threads within a process will share 
• the address space
• open files
• other resources
• Potential for efficient and close cooperation

2. Multithreading

• when a multithread process is run on a single CPU system, the threads take turns running
• All threads in the process have exactly the same address space
• each thread can be in any one of the several states, just like processes
• Each thread has its own stack

3. Benefits

• Responsiveness
• multithreading an interactive application may allow a program to continue running even if part of it is blocked or performing a lengthy operation
• Resource sharing
• sharing the address space and other resources may result in high degree of cooperation
• Economy
• creating/managing processes is much more time consuming than managing threads
• Better utilization of multiprocessor architectures

4. Example: a multi-threaded web server

5. Implementing threads

• processes usually start with a single thread
• usually, library procedures are invoked to manage threads
• thread_create: typically specifies the name of the procedure for the new thread to run
• thread_exit
• thread_join: blocks the calling thread until another (specific) thread has exited
• thread_yield: voluntarily gives up the CPU to let another thread run
• threads may be implemented in the user space or in the kernel space

6. User-level thread

• user threads are supported above the kernel and are implemented by a thread library at the user level
• the library (or run-time system) provides support for thread creation, scheduling and management with no support from the kernel
• when threads are managed in user space, each process needs its own private thread table to keep track of the threads in that process
•  the thread-table keeps track only of the per-thread items (program counter, stack pointer, register, state...)
• when a thread does something that may cause it to be blocked locally (e.g., wait for another thread), it calls a run time system procedure
• if the thread must be put into blocked state, the procedure performs switching

7. User-level advantage

• the operating system does not need to support multi-threading
• since the kernel is not involved, thread switching may be very fast
• each process may have its own customized thread scheduling algorithm
• thread scheduler may be implemented in the user space very efficiently

8. User-level threads: problems

• the implementation of blocking system calls is highly problematic (e.g., read from the keyboard). All the threads in the process risk being blocked
• Possible solutions
• change all system-call to non-blocking
• sometimes it may be possible to tell in advance if a call will block (e.g., select system call in some version of unix) 
• jacket code round system calls

9. Kernel-level threads

• kernel threads are supported directly by the OS
• the kernel provide threat creation, scheduling and management in the kernel space
• the kernel has a thread table that keeps track of all threads in the system
• all calls that might block a thread are implemented as system call (at greater cost)
• when a thread blocks, the kernel may choose another thread from the same process, or a thread from a different process

10. Hybrid Implementation

• An alternative solution is to user kernel-level threads, and then multiplex user-level threads onto some or all of the kernel threads
• A kernel-level thread has some set of user-level threads that take turns using it

11. Windows XP threads

• windows XP support kernel-level threads
• the primary data structures of a thread are 
• ETHREAD (executive thread blocks)
• thread start address
• pointer to parent process
• pointer to corresponding KTHREAD
• KTHREAD (kernel thread block)
• scheduling and synchronizing information
• kernel stack (used when the thread is running in kernel mode)
• pointer to TEB
• TEB (thread environment block)
• thread identifier
• user-mode stack
• thread-local storage

12. Linux Threads

• In addition to fork() system call, Linux provides the clone() system call, which may be used to create threads
• Linux users the term task (rather than process or thread) when referring to a flow of control
• A set of flags, passed as arguments to the clone() system call determine how much sharing is involved (e.g., open files, memory space, etc).