An operating system executes a variety of programs:
~ Batch system – jobs
~ Time-shared systems – user programs or tasks
Textbook uses the terms job and process almost
interchangeably.
Process – a program in execution; process execution
must progress in sequential fashion.
A process includes:
~ program counter
~ stack
~ data section
-----------------
As a process executes, it changes state
~ new: The process is being created.
~ running: Instructions are being executed.
~ waiting: The process is waiting for some event to occur.
~ ready: The process is waiting to be assigned to a processor
~ terminated: The process has finished execution.
Diagram of Process State
Information associated with each process
~ Process state
~ Program counter
~ CPU registers
~ CPU scheduling information
~ Memory-management information
~ Accounting information
~ I/O status information
Process Control Block (PCB)
In computer science, a thread of execution results from a fork of a computer program into two or more concurrently running tasks. The implementation of threads and processes differs from one operating system to another, but in most cases, a thread is contained inside a process. Multiple threads can exist within the same process and share resources such as memory, while different processes do not share these resources.
On a single processor, multithreading generally occurs by time-division multiplexing (as in multitasking): the processor switches between different threads. This context switching generally happens frequently enough that the user perceives the threads or tasks as running at the same time. On a multiprocessor or multi-core system, the threads or tasks will generally run at the same time, with each processor or core running a particular thread or task. Support for threads in programming languages varies: a number of languages simply do not support having more than one execution context inside the same program executing at the same time. Examples of such languages include Python, and OCaml, because the parallel support of their runtime support is limited by the use of a central lock, called "Global Interpreter Lock" in Python, "master lock" in Ocaml. Other languages may be limited because they use threads that are user threads, which are not visible to the kernel, and thus cannot be scheduled to run concurrently. On the other hand, kernel threads, which are visible to the kernel, can run concurrently.
Many modern operating systems directly support both time-sliced and multiprocessor threading with a process scheduler. The kernel of an operating system allows programmers to manipulate threads via the system call interface. Some implementations are called a kernel thread, whereas a lightweight process (LWP) is a specific type of kernel thread that shares the same state and information.
Programs can have user-space threads when threading with timers, signals, or other methods to interrupt their own execution, performing a sort of ad-hoc time-slicing.
Threads compared with processes
Threads differ from traditional multitasking operating system processes in that:
~ processes are typically independent, while threads exist as subsets of a process
~ processes carry considerable state information, where multiple threads within a process share state as well as memory and other resources
~ processes have separate address spaces, where threads share their address space
~ processes interact only through system-provided inter-process communication mechanisms.
~ Context switching between threads in the same process is typically faster than context switching between processes.
Systems like Windows NT and OS/2 are said to have "cheap" threads and "expensive" processes; in other operating systems there is not so great a difference except the cost of address space switch which implies a TLB flush.
0 comments:
Post a Comment