processes Threads
Traditional have one thread of control sequential program. Multiple threads of control are possible to get parallelism. Processes - own resources (resource grouping) - are scheduled for running (have states (Running, Ready, Blocked)) (execution)
Threads
The two properties of processes (resource grouping, execution) could be treated independently. Many modern OS's distinguish these and have threads, or lightweight processes. The thread is what is scheduled for execution, with the process still owning resources.
In a Multithreaded OS
A process has - a virtual address space for the process image - protected access to resources (processors, other processes, files etc.) The threads take on the properties for execution.
In a Multithreaded OS
Each thread in a process has - an execution state (Running, Ready, Blocked) - a saved thread context when not running thread program counter - an execution stack - per-thread storage for variables - access to memory and resources of the process, shared with all the other threads of the process. (share open files) - registers
Multithreading
Allows OS to switch between threads. - single processor case - multiprocessor case Threads of a process share the same address space with no protection from each other. All threads in a process run as same user so this is not a prob. Usually they cooperate to work on a problem or task.
Threads
Create new threads with a thread_create function that takes what function to run in the thread. A thread can exit with a thread_exit call. Also have thread_wait and thread_yield calls. POSIX thread standard - -lpthread pthread_create(3C)
go over sample pthreads program
Why Use Threads?
Multiple things can be done at once - parallel, multiprocessor, performance Programming model becomes simpler Advantages of threads over multiple cooperating processes in their shared address space and shared data. Easier to create and destroy than procs. - do not own resources Even on a single processor performance can be improved by overlapping cpu and I/O bound threads.
Why Use Threads? (cont)
Increased application throughput ( a process can have a # of outstanding blocking requests.) Increased application responsiveness (blocking one part of a process doesn't have to block the whole process) Improve GUI responsiveness - one thread interacts user with - others can be doing things on the cpu
Thread implementations
Threads can be implemented in user or kernel space (or combined in both). With threads in user space only, the kernel knows nothing about them. Process is single threaded to the kernel. OS does not need to support threads. Each process needs its own thread table. Much faster to do thread switching in user space rather than going to the kernel.
Advantages of user-level threads
Each process can have its own scheduling algorithm. Do not need to worry about a thread being stopped. Scale better kernel threads take up space in kernel.
Problems with user-level threads
Blocking system calls - blocks all the threads of the process - could work around by checking to see if call would block first (use select()) Page faults block entire process (all threads in the process) Threads must yield the cpu Many common uses use blocking system calls.
Kernel level threads
With kernel-level threads the kernel keeps a thread table with all the threads in system in it. When a thread blocks another can be scheduled (from same process or another one). Can better take advantage of multi-cpu system. Can run multiple threads from a process at the same time.
Hybrid threads
With a combined (Hybrid) approach positives from both user (good performance) and kernel (use less tricks) can be had. And minimize disadvantages. User-level threads are...