Multithreading Introduction and Lifecyle of thread

Multithreading PRESENTED BY –: Kartik dube (008)

 Process is a isolated, independently executing programs to which OS allocate resources such as memory, file handlers, security credentials, etc.  Processes communicate with one another through mechanisms like sockets, signal handlers, shared memory, semaphores and files.

 Threads are called lightweight processes.  Threads are parts of Processes. So all the threads created by one particular process can share the process's resources (memory, file handlers, etc).  There may be several threads in one process  Threads are independent because they all have separate path of execution that’s the reason if an exception occurs in one thread, it doesn’t affect the execution of other threads.

What is Multithreading ?  The process of executing multiple threads simultaneously is known as multithreading.

Before we talk about multithreading, Back in the old days a computer had a single CPU, and was only capable of executing a single program at a time. Later came multitasking which meant that computers could execute multiple programs (processes) at the same time. . The single CPU was shared between the programs. The operating system would switch between the programs running, executing each of them for a little while before switching. Later yet came multithreading which mean that you could have multiple threads of execution inside the same program.

Multithreading can be a great way to increase the performance of some types of programs. Multithreading extends the idea of multitasking into applications, so you can subdivide specific operations within a single application into individual Threads. Each of the threads can run in parallel. For example, one subprogram can display an animation on the screen while another may build the next animation to be displayed. Since all the threads are running on a single processor, the flow of execution is shared between the threads. The java interpreter handles the switching of control between the threads in such a way that it appears they are running concurrently.

A Thread is a basic unit of CPU utilization, consisting of a program counter, a stack, and a set of registers, ( and a thread ID. ) Traditional ( heavyweight ) processes have a single thread of control - There is one program counter, and one sequence of instructions that can be carried out at any given time. As shown in Figure , multi-threaded applications have multiple threads within a single process, each having their own program counter, stack and set of registers, but sharing common code, data, and certain structures such as open files.

Figure - Single-threaded and multithreaded processes

Life Cycle of Thread  During the life time of a thread, there are many states it can enter. They include: 1. Newborn state 2. Runnable State 3. Running State 4. Blocked State 5. Dead State

1. Newborn State Thread t1 = new Thread(); In new born state, the thread object is just created but not started yet, we can say it is inactive. In the above statement t1 thread is created but not started. To make the thread active, call start() method on the thread object as t1.start(). This makes the thread active and now eligible to run, now it goes to runnable state.

2. Runnable state (start()) The runnable state means that the thread is ready for execution and is waiting for the availability of the processor.

2. Runnable state (start())  When the thread is active, the first and foremost job, it does is calling run() method.  When the thread is executing the run() method, we say, the thread is in runnable state.As it is a callback method, all the code expected to run by the thread, is written here. In this state, the thread is active.

3. Running State  Running means that the processor has given its time to the thread for its execution.  A running thread may relinquish its control in one of the following situations:

1. Suspend() and resume() Methods:- This approach is useful when we want to suspend a thread for some time due to certain reason, but do not want to kill it. Running Runnable Suspended suspended resume

2. Sleep() Method :- This means that the thread is out of the queue during this time period. The thread re-enter the runnable state as soon as this time period is elapsed. Running Runnable Sleeping sleep(t)

3. Wait() and notify() methods :- blocked until certain condition occurs Running Runnable Waiting wait notify

4. Blocked State  A thread is said to be blocked when it is prevented form entering into the runnable state and subsequently the running state.  This happens when the thread is suspended, sleeping, or waiting in order to satisfy certain requirements.

5. Dead State  A running thread ends its life when is has completed executing its run() method. It is a natural death.  However, we can kill it by sending the stop message to it at any state thus causing a premature death to it.  A thread can be killed as soon it is born, or while it is running, or even when it is in “not runnable” (blocked) condition.

State diagram of a thread yield Newborn start stop stop stop suspended sleep wait resume notify Blocked Dead Running RunnableActive Thread New Thread Idle Thread (Not Runnable) Killed Thread

How to create thread  Thread class provide constructors and methods to create and perform operations on a thread. Thread class extends Object class and implements Runnable interface.  A new thread can be created in two ways:  By extending a thread class  By implementing an interface

Commonly used methods of Thread class: • public void run(): is used to perform action for a thread. • public void start(): starts the execution of the thread.JVM calls the run() method on the thread. • public void sleep(long miliseconds): Causes the currently executing thread to sleep (temporarily cease execution) for the specified number of milliseconds. • public void join(): waits for a thread to die. • public int getPriority(): returns the priority of the thread. • public int setPriority(int priority): changes the priority of the thread. • public String getName(): returns the name of the thread. • public void setName(String name): changes the name of the thread. • public int getId(): returns the id of the thread. • public void yield(): causes the currently executing thread object to temporarily pause and allow other threads to execute. • public void suspend(): is used to suspend the thread. • public void resume(): is used to resume the suspended thread. • public void stop(): is used to stop the thread..

Create a Thread by Implementing a Runnable Interface Step 1 : As a first step, you need to implement a run() method provided by a Runnable interface. This method provides an entry point for the thread and you will put your complete business logic inside this method. Following is a simple syntax of the run() method − public void run( ) { // }

Thread(Runnable threadObj); Where, threadObj is an instance of a class that implements the Runnable interface Step 2 : As a second step, you will instantiate a Thread object using the following constructor − Create a Thread by Implementing a Runnable Interface

Step 3 : Once a Thread object is created, you can start it by calling start() method, which executes a call to run( ) method. Following is a simple syntax of start() method − void start(); Create a Thread by Implementing a Runnable Interface

class TDemo implements Runnable { public void run() { for(int i=0;i<=5;i++) { System.out.println("CONCURRENT THREAD RUNNING SIMUNTANIOUSLY......!!!.....:"+i); } } } class Main_TDemo1 { public static void main(String arg[]) { TDemo obj = new TDemo(); Thread t = new Thread(obj); t.start(); } } Example

Create a Thread by Extending the Thread class  We can directly extend the Thread class  The class TDemo extends Thread. The logic for the thread is contained in the run() method.

class TDemo extends Thread { public void run() { for(int i=0;i<=5;i++) { System.out.println("CONCURRENT THREAD RUNNING SIMUNTANIOUSLY......!!!.....:"+i); } } } class Main_TDemo1 { public static void main(String arg[]) { TDemo obj = new TDemo(); obj.start(); } } Example

Synchronization  When we start two or more threads within a program, there may be a situation when multiple threads try to access the same resource and finally they can produce unforeseen result due to concurrency issues.  For example, if multiple threads try to write within a same file then they may corrupt the data because one of the threads can override data or while one thread is opening the same file at the same time another thread might be closing the same file.

 Java programming language provides a very handy way of creating threads and synchronizing their task by using synchronized blocks. You keep shared resources within this block synchronized (object) { //statement to be synchronized } Synchronization

Why use Synchronization The synchronization is mainly used to :- • To prevent thread interference. • To prevent consistency problem.

class MDemo { public static void main(String arg[])throws InterruptedException { SDemo obj = new SDemo(); Thread t1 = new Thread(obj); Thread t2 = new Thread(obj); t1.start(); t2.start(); } }

class SDemo implements Runnable { int avail = 1; int req = 1; public void run() { System.out.println("AVAILABLE BIRTH = "+avail); synchronized(this) { if(avail >= req) { System.out.println("1 BIRTH IS RESERVED"); try { Thread.sleep(2000); avail = avail-req; } catch(Exception e){} } else System.out.println("RECENTLY NO BIRTH AVAILABLE "); } } }

Multithreading Introduction and Lifecyle of thread

More Related Content

What's hot

Similar to Multithreading Introduction and Lifecyle of thread

Recently uploaded

Multithreading Introduction and Lifecyle of thread