Parallel Execution<\/strong>: Multithreading enables different parts of a program to run concurrently, improving performance and responsiveness.<\/p>\n\n\n\n Improving performance <\/strong>: By allowing threads to run concurrently, multithreading can make better use of cpu resources, leading to faster execution of tasks.<\/p>\n\n\n\n Efficient Resource Usage<\/strong>: By sharing the process’s memory and resources, threads are more efficient than creating multiple processes.<\/p>\n\n\n\n Scalability<\/strong>: Multithreading can help applications scale better on multicore processors leveraging the full potential of modern hardware .<\/p>\n\n\n\n Multithreading is particularly useful for taking advantage of multi-core processors, where each thread can run on a separate core.However, it requires careful management to avoid issues like:<\/p>\n\n\n\n Resource contention<\/strong>: When threads compete for limited system resources.<\/p>\n\n\n\n Race conditions<\/strong>: When two or more threads try to modify shared data simultaneously.<\/p>\n\n\n\n Deadlocks<\/strong>: Deadlocks occur when multiple threads become stuck, each waiting for the other to release resources, causing a system halt.<\/p>\n\n\n\n In multithreading, threads share the same memory space and resources of the process they belong to. Here’s how memory allocation works for threads:<\/p>\n\n\n\n The thread lifecycle in Java describes the various states a thread can go through from its creation to termination.<\/p>\n\n\n\n Two way we can create a thread in java using Thread <\/strong>class and Runnable <\/strong>Interface<\/p>\n\n\n\n 2.Creating Threads Using the Above code explanation <\/strong><\/p>\n\n\n\nHow Thread Will Allocate Memory<\/h5>\n\n\n\n
\n
Thread life cycle<\/h5>\n\n\n\n
![\"\"](\"https:\/\/rkdigitalschool.in\/itwala\/wp-content\/uploads\/2025\/04\/thead-lifecycle.png\")
<\/figure>\n\n\n\nThread States<\/strong><\/h6>\n\n\n\n
\n
\n
Thread t = new Thread();<\/code><\/li>\n\n\n\nrun()<\/code> method yet.<\/li>\n<\/ul>\n<\/li>\n\n\n\n\n
start()<\/code> method is called, the thread enters the “Runnable” state.<\/li>\n\n\n\nt.start();<\/code><\/li>\n<\/ul>\n<\/li>\n\n\n\n\n
run()<\/code> method. The JVM scheduler selects it for execution.<\/li>\n\n\n\n\n
\n
wait()<\/code>).<\/li>\n\n\n\nsleep()<\/code> or join(timeout)<\/code>).<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<\/li>\n\n\n\n\n
run()<\/code> method finishes, the thread is considered “dead.”<\/li>\n<\/ul>\n<\/li>\n<\/ol>\n\n\n\nHow many way we can create thread . <\/h5>\n\n\n\n
\n
Thread<\/code> Class<\/strong><\/li>\n<\/ol>\n\n\n\n\/\/ Extending the Thread class\nclass MyThread extends Thread {\n @Override\n public void run() {\n System.out.println(\"Hello from MyThread: \" + Thread.currentThread().getName());\n }\n}\n\npublic class ThreadExample {\n public static void main(String[] args) {\n \/\/ Creating and starting threads\n MyThread thread1 = new MyThread();\n MyThread thread2 = new MyThread();\n\n thread1.start(); \/\/ Start thread1\n thread2.start(); \/\/ Start thread2\n }\n}\n<\/code><\/pre>\n\n\n\nKey Points:<\/strong><\/h6>\n\n\n\n
\n
start()<\/code> Method<\/strong>: This is used to begin thread execution, invoking the run()<\/code> method internally.<\/li>\n\n\n\nrun()<\/code> Method<\/strong>: Contains the code to be executed by the thread.<\/li>\n\n\n\nThread.currentThread().getName()<\/code> helps identify the currently executing thread.<\/li>\n<\/ol>\n\n\n\nMemory Allocation of Above Program<\/strong><\/h6>\n\n\n\n
\n
\n
MyThread thread1 = new MyThread();<\/code> and MyThread thread2 = new MyThread();<\/code> are executed, two objects of the MyThread<\/code> class are created in the heap memory<\/strong>.<\/li>\n\n\n\nMyThread<\/code> objects (instances thread1<\/code> and thread2<\/code>) reside.<\/li>\n<\/ul>\n<\/li>\n\n\n\n\n
thread1<\/code> and thread2<\/code>) has its own stack memory<\/strong>.<\/li>\n\n\n\nrun()<\/code> method executes for each thread, the method’s context (parameters, local variables, and return address) is stored in its respective stack.<\/li>\n<\/ul>\n<\/li>\n\n\n\n\n
run()<\/code> method does not use shared variables; it only prints the thread’s name using Thread.currentThread().getName()<\/code>. <\/li>\n<\/ul>\n<\/li>\n\n\n\n\n
Thread.currentThread()<\/code> object represents the current thread and exists in thread-specific storage. Each thread maintains its own identity and state (such as name, priority, etc.) in this storage.<\/li>\n<\/ul>\n<\/li>\n\n\n\n\n
thread1<\/code> and thread2<\/code> complete execution, they are eligible for garbage collection since there are no active references to these objects. The JVM automatically handles this cleanup process.<\/li>\n<\/ul>\n<\/li>\n<\/ol>\n\n\n\nRunnable<\/code> Interface<\/strong><\/p>\n\n\n\nclass MyRunnable implements Runnable { \n @Override\n public void run() {\n System.out.println(\"Hello from MyRunnable: \" + Thread.currentThread().getName());\n }\n}\n\npublic class RunnableExample {\n public static void main(String[] args) {\n \/\/ Creating and starting threads\n Thread thread1 = new Thread(new MyRunnable());\n Thread thread2 = new Thread(new MyRunnable());\n\n thread1.start(); \/\/ Start thread1\n thread2.start(); \/\/ Start thread2\n }\n}\n\n<\/code><\/pre>\n\n\n\n1. <\/strong>
class MyRunnable implements Runnable {<\/code><\/h4>\n\n\n\n\n
MyRunnable<\/code> is defined, which implements the Runnable<\/code> interface.<\/li>\n\n\n\nMyRunnable<\/code> must provide an implementation for the run()<\/code> method, as required by the Runnable<\/code> interface.<\/li>\n<\/ul>\n\n\n\n2. <\/strong>
@Override public void run() {<\/code><\/h4>\n\n\n\n\n
run()<\/code> method is overridden in the MyRunnable<\/code> class.<\/li>\n\n\n\nrun()<\/code> method is what gets executed.<\/li>\n<\/ul>\n\n\n\n3. <\/strong>
System.out.println(\"Hello from MyRunnable: \" + Thread.currentThread().getName());<\/code><\/h4>\n\n\n\n\n
run()<\/code> method prints a message to the console with the name of the current thread (Thread.currentThread().getName()<\/code>).<\/li>\n\n\n\nThread.currentThread()<\/code> retrieves the thread currently executing the run()<\/code> method.<\/li>\n<\/ul>\n\n\n\n4. <\/strong>
public class RunnableExample {<\/code><\/h4>\n\n\n\n\n
RunnableExample<\/code> class acts as the entry point for the program. Its main()<\/code> method is where the threads are created and started.<\/li>\n<\/ul>\n\n\n\n5. <\/strong>
Thread thread1 = new Thread(new MyRunnable());<\/code><\/h4>\n\n\n\n\n
Thread<\/code> object is created, and the MyRunnable<\/code> instance is passed as its argument.\n\n
\n
MyRunnable<\/code> is created in heap memory<\/strong>.<\/li>\n\n\n\nThread<\/code> object thread1<\/code> is also created in heap memory<\/strong>.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n\n\n\n6. <\/strong>
Thread thread2 = new Thread(new MyRunnable());<\/code><\/h4>\n\n\n\n\n
Thread<\/code> object is created, with another MyRunnable<\/code> instance as its argument.\n\n
\n
MyRunnable<\/code> object is created in heap memory<\/strong>.<\/li>\n\n\n\nThread<\/code> object thread2<\/code> is also stored in heap memory<\/strong>.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n\n\n\n7. <\/strong>
thread1.start();<\/code><\/h4>\n\n\n\n\n
start()<\/code> method is called on thread1<\/code>.\n\n
run()<\/code> method of the MyRunnable<\/code> instance associated with thread1<\/code>.<\/li>\n\n\n\n\n
thread1<\/code>. The stack contains local variables and execution context for the run()<\/code> method.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n\n\n\n8. <\/strong>
thread2.start();<\/code><\/h4>\n\n\n\n\n
start()<\/code> method is called on thread2<\/code>.\n\n
run()<\/code> method of the second MyRunnable<\/code> instance in a new thread.<\/li>\n\n\n\n\n
thread2<\/code>.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n\n\n\nMemory Management Overview<\/h5>\n\n\n\n
\n
\n