Concept of Threads in Computer Programming:
Basically
Thread is concept of System's OS, That is now being implemented by
programmers in various places of application development and testing.
What is a Thread?
In computer science, a thread
of execution is the smallest sequence of programmed instructions that
can be managed independently by a scheduler, which is typically a part
of the operating system. Multiple
threads can exist within one process, executing concurrently and
sharing resources such as memory, while different processes do not share
these resources.
 |
| A process with two threads of execution, running on one processor |
What is a Process?
A process
is the instance of a computer program that is being executed. It
contains the program code and its activity. Depending on the operating
system (OS), a process may be made up of multiple threads of execution
that execute instructions concurrently.
A computer program is a passive collection of instructions,
a process is the actual execution of those instructions. Several
processes may be associated with the same program; for example, opening
up several instances of the same program often results in more than one
process being executed.
Threads vs. 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 considerably more state information than threads, whereas multiple threads within a process share process state as well as memory and other resources.
- processes have separate address spaces, whereas threads share their address space
- context switching between threads in the same process is typically faster than context switching between processes.
Threads in Single Processor and Multiprocessor Systems:
Systems with a single processor generally implement multithreading by time slicing: the central processing unit (CPU) switches between different software threads. This context switching generally happens very often and rapidly enough that users perceive the threads or tasks as running in parallel.
While On a multiprocessor or multi-core system, multiple threads can execute in parallel, with every processor or core executing a separate thread simultaneously; on a processor or core.
The process schedulers of many modern operating systems directly support both time-sliced and multiprocessor threading, and the operating system kernel allows programmers to manipulate threads by exposing required functionality through the system-call interface.
Time Slicing:
The period of time for which a process is allowed to run in a preemptive multitasking system is generally called the time slice or quantum.
The scheduler is run once every time slice to choose the next process
to run. The length of each time slice can be critical to balancing
system performance vs process responsiveness - if the time slice is too
short then the scheduler will consume too much processing time, but if
the time slice is too long, processes will take longer to respond to
input.
An interrupt is scheduled to allow the operating system kernel
to switch between processes when their time slices expire, effectively
allowing the processor’s time to be shared between a number of tasks,
giving the illusion that it is dealing with these tasks in parallel
(simultaneously). The operating system which controls such a design is
called a multi-tasking system
Multitasking System:
Multitasking
is a method used by system's OS to allow multiple processes to share
processors (CPUs) and other system resources. Each CPU (core) executes a single task at a time.
However, multitasking allows each processor to switch between tasks
that are being executed without having to wait for each task to finish.
Single-Threading and Multi-Threading:
Single Threading:
single-threading is the processing of one command at a time. The opposite of single-threading is multi-threading
Multi-Threading:
Multi-threading is mainly found in multitasking operating systems.
Multi-threading is a widespread programming and execution model that
allows multiple threads to exist within the context of one process.
These threads share the process's resources, but are able to execute
independently. The threaded programming model provides developers with a
useful abstraction of concurrent execution. Multi-threading can also be
applied to one process to enable parallel execution on a multiprocessing system.
- Responsiveness: multi-threading can allow an application to remain responsive to input. In a one-thread program, if the main execution thread blocks on a long-running task, the entire application can appear to freeze. By moving such long-running tasks to a worker thread that runs concurrently with the main execution thread, it is possible for the application to remain responsive to user input while executing tasks in the background. On the other hand, in most cases multi-threading is not the only way to keep a program responsive, with non-blocking I/O and/or Unix signals being available for gaining similar results.[6]
- Faster execution: this advantage of a multi-threaded program allows it to operate faster on computer systems that have multiple central processing units (CPUs) or one or more multi-core processors, or across a cluster of machines, because the threads of the program naturally lend themselves to parallel execution, assuming sufficient independence (that they do not need to wait for each other).
- Lower resource consumption: using threads, an application can serve multiple clients concurrently using fewer resources than it would need when using multiple process copies of itself. For example, the Apache HTTP server uses thread pools: a pool of listener threads for listening to incoming requests, and a pool of server threads for processing those requests.
- Better system utilization: as an example, a file system using multiple threads can achieve higher throughput and lower latency since data in a faster medium (such as cache memory) can be retrieved by one thread while another thread retrieves data from a slower medium (such as external storage) with neither thread waiting for the other to finish.
- Simplified sharing and communication: unlike processes, which require a message passing or shared memory mechanism to perform inter-process communication (IPC), threads can communicate through data, code and files they already share.
- Parallelization: applications looking to use multicore or multi-CPU systems can use multithreading to split data and tasks into parallel subtasks and let the underlying architecture manage how the threads run, either concurrently on one core or in parallel on multiple cores. GPU computing environments like CUDA and OpenCL use the multithreading model where dozens to hundreds of threads run in parallel across data on a large number of cores.
- Synchronization: since threads share the same address space, the programmer must be careful to avoid race conditions and other non-intuitive behaviors. In order for data to be correctly manipulated, threads will often need to rendezvous in time in order to process the data in the correct order. Threads may also require mutually exclusive operations (often implemented using mutexes) in order to prevent common data from being simultaneously modified or read while in the process of being modified. Careless use of such primitives can lead to deadlocks, livelocks or races over resources.
- Thread crashes a process: an illegal operation performed by a thread crashes the entire process; therefore, one misbehaving thread can disrupt the processing of all the other threads in the application.
Confusing Terms:
Multi-processing: Multiple processes runs in parallel.Multi-threading: Multiple Threads runs in parallel.
Multitasking can achieved by multi-processing and multi-threading.
Above paragraph explains the concept of Threads And How an OS manages to provide multitasking and runs multiple applications in parallel. Further, We will See Threads in Java in next post:
