The document outlines key differences between processes and threads, highlighting that processes operate in separate memory spaces while threads share the same memory space within a process. It discusses advantages and disadvantages of each, including scalability, resource consumption, security, and debugging ease, along with a comparison table. The document further includes a Java code example demonstrating how to create and manage a thread.

1. Multithreading

2. Difference Between Process and Thread
• Difference between process and thread" is one of the widely asked
questions of technical interviews.
• Both processes and threads are related to each other and very much
similar, hence create confusion to understand the differences
between both of them.
• The process and thread are an independent sequence of execution,
but both are differentiated in a way that processes execute in
different memory spaces, whereas threads of the same process
execute in shared memory space.

4. • Regarding concurrent programming in Java, there are two options for
executing many tasks simultaneously: processes and threads. While
they both provide comparable advantages, there are some significant
distinctions between them. Here's a table that compares Java
processes and threads:

5. Process Thread
A self-contained program that runs in its memory
area.
A lightweight execution unit within a process.
Each process has its memory area that is not shared
by any other process.
A process's threads share the same memory area.
Inter-process communication (IPC) is essential for
process communication.
Inter-thread communication (ITC) may be done
quickly and easily using shared memory.
Developing a new method is a costly endeavor. It is relatively inexpensive to start a new thread.
Switching between processes incurs significant
overhead.
It is less costly to switch between threads inside a
process.
Processes can execute on different CPUs, allowing
for real parallelism.
Threads can only execute on one CPU at a time and
can only provide pseudo-parallelism.
When one process fails, it does not affect the other
processes.
If one thread fails, the entire process may suffer.
Because of the expense associated with designing
and monitoring processes, they are less scalable.
Threads are more scalable since they are lightweight
and easier to build and manage.

6. Because processes cannot share memory, synchronization
needs IPC techniques such as semaphores, mutexes, or pipes.
Threads inside a process can use shared memory and lock
objects to synchronize.
Because of the expense of context switching, processes might
require additional CPU resources.
Threads can use CPU resources more effectively since
switching between them requires less overhead.
Debugging a multi-process application might be more
difficult since each process operates independently.
Debugging a multithreaded program can be simplified since
threads share the same memory space and can be debugged
concurrently.
Processes are more secure because they execute in their
memory area, decreasing the possibility of one process
accessing the memory of another.
Threads are more exposed to security concerns since they
share the same memory space and can directly access each
other's memory.
Processes are more portable since they can execute on
various operating systems with varying architectures.
Threads may be less portable because their behavior varies
depending on the underlying operating system and
hardware.
When a process crashes, it does not affect other processes
operating on the system.
If a thread fails, the entire process might fail.
Processes have separate memory spaces, while threads share
the same memory space as the parent process.
Threads can communicate with each other more easily and
can access the same data structures.
Creating a new process is more resource-intensive than
creating a new thread. A new process requires a separate
memory space and operating system resources.
Using fewer operating system resources, a new thread can be
created within the same memory space.
Processes are often used for processes that must be Threads are used for operations that must cooperate.

7. public class MyThread implements Runnable {
public void run() {
// Perform some task
System.out.println("Thread " + Thread.currentThread().getName() + " is running");
}
public static void main(String[] args) {
// Create a new thread
Thread t1 = new Thread(new MyThread(), "Thread 1");
// Start the thread
t1.start();
// Wait for the thread to finish
try {
t1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Thread " + t1.getName() + " has finished");
}
}
OUTPUT:
Thread Thread 1 is running
Thread Thread 1 has finished

8. Explanation
• The example shows how to start a new thread in Java. The Runnable
interface describes the job the thread will complete, and the run()
function is modified to give the task implementation. The Thread class
starts a new thread by supplying an instance of the MyThread class
and a thread name. The start() method initiates the thread, while the
join() method waits for the thread to complete before proceeding.
Finally, a message is written to indicate that the thread is complete.