Processes vs Threads
This is a very common interview question that has been asked at companies like Yahoo, Apple, and NCR.
A process is an executing instance of an application. For example, when you double-click the Microsoft Word icon, you start a process that runs Word.
A thread is a path of execution within a process. Also, a process can contain multiple threads.
When you start Word, the operating system creates a process and begins executing the primary thread of that process.
It's important to note that a thread can do anything a process can do. But since a process can consist of multiple threads, a thread could be considered a 'lightweight' process.
Thus, the essential difference between a thread and a process is the work that each one is used to accomplish.
Threads are used for small tasks, whereas processes are used for more 'heavyweight' tasks - basically the execution of applications.
Advertisement: Search Jobs That Pay Over $100,000
Another difference between a thread and a process is that threads within the same process share
the same address space, whereas different processes do not.
This allows threads to read from and write to the same data structures and variables,
and also facilitates communication between threads. Communication between processes - also
known as IPC, or inter-process communication - is quite difficult and resource-intensive.
Threads, of course, allow for multi-threading. A common example of the advantage of multithreading is
the fact that you can have a word processor that prints a document using a background thread, but at
the same time another thread is running that accepts user input, so that you can type up a new document.
If we were dealing with an application that uses only one thread, then the application would only be
able to do one thing at a time - so printing and responding to user input at the same time would not
be possible in a single threaded application.
Each process has it's own address space, but the threads within the same process share that address
space. Threads also share any other resources within that process. This means that it's very easy to
share data amongst threads, but it's also easy for the threads to step on each other, which can lead to
Multithreaded programs must be carefully programmed to prevent those bad things from happening.
Sections of code that modify data structures shared by multiple threads are called critical sections.
When a critical section is running in one thread it's extremely important that no other thread be
allowed into that critical section. This is called synchronization, which we wont get into any
further over here. But, the point is that multithreading requires careful programming.
Also, context switching between threads is generally less expensive than in processes.
And finally, the overhead (the cost of communication) between threads is very low relative to processes.
Here's a summary of the differences between threads and processes:
1. Threads are easier to create than processes since they
don't require a separate address space.
2. Multithreading requires careful programming since threads
share data strucures that should only be modified by one thread
at a time. Unlike threads, processes don't share the same
3. Threads are considered lightweight because they use far
less resources than processes.
4. Processes are independent of each other. Threads, since they
share the same address space are interdependent, so caution must be
taken so that different threads don't step on each other. This is
really another way of stating #2 above.
5. A process can consist of multiple threads.