Scribd Logo
Upload

Welcome to Scribd!

  • 263 views

    Multithreading and Exception Handling

    Uploaded by

    Balakrishnan.G
    The document discusses multithreading and exception handling in Java. It covers key concepts like the life cycle of a thread, creating threads using Runnable interface and extending Thread class, setting thread priority, and handling exceptions using try-catch blocks and keywords like try, catch, finally, throw and throws. It also provides examples to demonstrate multithreading and exception handling concepts in Java.

    Copyright:

    © All Rights Reserved
    Download as PPT, PDF, TXT or read online from Scribd

    Multithreading and Exception Handling

    Uploaded by

    Balakrishnan.G
    263 views40 pages
    The document discusses multithreading and exception handling in Java. It covers key concepts like the life cycle of a thread, creating threads using Runnable interface and extending Thread class, setting thread priority, and handling exceptions using try-catch blocks and keywords like try, catch, finally, throw and throws. It also provides examples to demonstrate multithreading and exception handling concepts in Java.

    Original Description:

    Multi Threading in JAVA

    Copyright

    © © All Rights Reserved

    Available Formats

    PPT, PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    The document discusses multithreading and exception handling in Java. It covers key concepts like the life cycle of a thread, creating threads using Runnable interface and extending Thread class, setting thread priority, and handling exceptions using try-catch blocks and keywords like try, catch, finally, throw and throws. It also provides examples to demonstrate multithreading and exception handling concepts in Java.

    Copyright:

    © All Rights Reserved
    Download as PPT, PDF, TXT or read online from Scribd
    Download as ppt, pdf, or txt
    263 views40 pages

    Multithreading and Exception Handling

    Uploaded by

    Balakrishnan.G
    The document discusses multithreading and exception handling in Java. It covers key concepts like the life cycle of a thread, creating threads using Runnable interface and extending Thread class, setting thread priority, and handling exceptions using try-catch blocks and keywords like try, catch, finally, throw and throws. It also provides examples to demonstrate multithreading and exception handling concepts in Java.

    Copyright:

    © All Rights Reserved
    Download as PPT, PDF, TXT or read online from Scribd
    Download as ppt, pdf, or txt
    of 40

    Multithreading and Exception

    Handling
    Introduction to Multithreading
    Java is a multi-threaded programming
    language which means we can develop multi-
    threaded program using Java.
    A multi-threaded program contains two or
    more parts that can run concurrently and each
    part can handle a different task at the same
    time making optimal use of the available
    resources
    By definition, multitasking is when multiple
    processes share common processing resources
    such as a CPU. Multi-threading extends the
    idea of multitasking into applications where
    you can subdivide specific operations within a
    single application into individual threads. Each
    of the threads can run in parallel.
    Life Cycle of a Thread
    A thread goes through various stages in its life
    cycle. For example, a thread is born, started,
    runs, and then dies. The following diagram
    shows the complete life cycle of a thread.
    New A new thread begins its life cycle in the new
    state. It remains in this state until the program starts
    the thread. It is also referred to as a born thread.
    Runnable After a newly born thread is started, the
    thread becomes runnable. A thread in this state is
    considered to be executing its task.
    Waiting Sometimes, a thread transitions to the
    waiting state while the thread waits for another thread
    to perform a task. A thread transitions back to the
    runnable state only when another thread signals the
    waiting thread to continue executing.
    Timed Waiting A runnable thread can enter
    the timed waiting state for a specified interval
    of time. A thread in this state transitions back
    to the runnable state when that time interval
    expires or when the event it is waiting for
    occurs.
    Terminated (Dead) A runnable thread enters
    the terminated state when it completes its
    task or otherwise terminates.
    Thread Priorities

    Every Java thread has a priority that helps the


    operating system determine the order in which threads
    are scheduled.
    Java thread priorities are in the range between
    MIN_PRIORITY (a constant of 1) and MAX_PRIORITY (a
    constant of 10). By default, every thread is given
    priority NORM_PRIORITY (a constant of 5).
    Threads with higher priority are more important to a
    program and should be allocated processor time before
    lower-priority threads. However, thread priorities
    cannot guarantee the order in which threads execute
    and are very much platform dependent.
    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( )
    Step 2
    As a second step, you will instantiate a Thread
    object using the following constructor
    Thread(Runnable threadObj, String
    threadName);
    Where, threadObj is an instance of a class that
    implements the Runnable interface and
    threadName is the name given to the new
    thread.
    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();
    Example Program
    Write a Java Program that prints the numbers
    from 1 to 10 line by line after every 10
    seconds
    Class Thread
    {
    Int num;
    Thread()
    {
    Start();
    }
    Public void run()
    {
    Try
    {
    For(int i=1;i<=10;i++)
    {
    System.out.println(i);
    Thread.sleep(10000);
    }
    }
    Catch(InterruptedException e)
    {
    System.out.println(Exception in Thread
    Handling);
    }}}
    Public class Multi
    {
    Public static void main(String args[])
    {
    Thread t1=new Thread();
    }
    }
    1,2,3,4,5,6,7,8,9,10
    Creation of Multiple Threads by
    Extending the thread class
    Class thread_demo extends Thread
    {
    String msg;
    Thread_demo(String str)
    {
    Msg=str;
    Start();
    }
    Public void run()
    {
    For(int i=1;i<=5;i++)
    {
    System.out.println(msg);}
    Try{
    Thread.sleep(10000);
    }
    Catch(InterruptedException e)
    {
    System.out.println(Exception in Thread
    Handling);}}}
    Public class ManyThread
    {
    Public static void main(String args[])
    {
    Thread_demo t1=new Thread_demo(First
    Thread);
    Thread_demo t2=new
    Thread_demo(Second);
    Thread_demo t3=new Thread_demo(Third);
    }
    }
    First Thread
    First Thread
    First Thread
    First Thread
    First Thread
    Second Thread Second Thread
    Second Thread
    Second Thread
    Third ThreadThird Thread
    Third Thread
    Third Thread
    Third Thread
    Runnable
    Class thread_demo implements Runnable
    {
    String str, msg; Thread t;
    Thread_demo(String str)
    {
    Msg=str;
    t=new Thread(this.str);
    t.Start();
    }
    Public void run()
    {
    For(int i=1;i<=5;i++)
    {
    System.out.println(msg);
    }
    Try{ Thread.sleep(10000);}
    Catch(interruptedException e)
    {
    System.out.println(Exception in Thread handling);
    }}}
    Public class ManyThreadRunnable{
    Public static void main(string args[])
    {
    Thread_demo t1=new Thread_demo(First Thread);
    Thread_demo t2=new Thread_demo(Second Thread);

    Thread_demo t3=new Thread_demo(Third Thread);}}


    First thread
    First thread
    First thread
    Second ThreadSecond Thread
    Second Thread
    Second Thread
    Second Thread
    First thread
    First thread
    Third Thread Third Thread
    Third Thread
    Third Thread
    Third Thread
    Exception Handling
    Scenario where NullPointerException occurs
    If we have null value in any variable,
    performing any operation by the variable
    occurs an NullPointerException.
    String s=null;
    System.out.println(s.length());//NullPointerExc
    eption
    1) Scenario where ArithmeticException
    occurs
    If we divide any number by zero, there occurs
    an ArithmeticException.
    int a=50/0;//ArithmeticException
    Scenario where NumberFormatException occurs
    The wrong formatting of any value, may occur
    NumberFormatException. Suppose I have a string
    variable that have characters, converting this
    variable into digit will occur
    NumberFormatException.
    String s="abc";
    int i=Integer.parseInt(s);//NumberFormatExceptio
    n
    4) Scenario where
    ArrayIndexOutOfBoundsException occurs
    If you are inserting any value in the wrong
    index, it would result
    ArrayIndexOutOfBoundsException as shown
    below:
    int a[]=new int[5];
    a[10]=50; //ArrayIndexOutOfBoundsException
    Java Exception Handling Keywords
    There are 5 keywords used in java exception
    handling.
    try
    catch
    finally
    throw
    throws
    Problem without exception handling
    Let's try to understand the problem if we don't
    use try-catch block.
    public class Testtrycatch1{
    public static void main(String args[]){
    int data=50/0;//may throw exception
    System.out.println("rest of the code...");
    }
    } Exception in thread main
    java.lang.ArithmeticException:/ by zero
    Class ExceptionDemo
    {
    Public static void main(String args[])
    { try {
    Int a,b;
    A=5;
    B=a/0;
    }
    Catch(ArithmeticException e)
    {
    System.out.println(Divide by Zero);
    }
    System.out.println(Executed catch
    statement);}}
    JAVA Multi Catch block
    If you have to perform different tasks at the occurrence of different
    Exceptions, use java multi catch block.
    public class TestMultipleCatchBlock{
    public static void main(String args[]){
    try{
    int a[]=new int[5];
    a[5]=30/0;
    }
    catch(ArithmeticException e){System.out.println("task1 is completed");}
    catch(ArrayIndexOutOfBoundsException e){System.out.println("task 2 co
    mpleted");}
    catch(Exception e){System.out.println("common task completed");}

    System.out.println("rest of the code...");


    }
    }
    Test it Now Output:task1 completed rest of the code...
    Nested Try block
    class Excep6{
    public static void main(String args[]){
    try{
    try{
    System.out.println("going to divide");
    int b =39/0;
    }catch(ArithmeticException e){System.out.println(e);}

    try{
    int a[]=new int[5];
    a[5]=4;
    }catch(ArrayIndexOutOfBoundsException e){System.out.println(e);}

    System.out.println("other statement);
    }catch(Exception e){System.out.println("handeled");}

    System.out.println("normal flow..");
    }
    }
    CASE 1 Usage of Java Finally
    Let's see the java finally example where exception doesn't occur.
    class TestFinallyBlock{
    public static void main(String args[]){
    try{
    int data=25/5;
    System.out.println(data);
    }
    catch(NullPointerException e){System.out.println(e);}
    finally{System.out.println("finally block is always executed");}
    System.out.println("rest of the code...");
    }
    }
    Test it Now Output:5 finally block is always executed rest of the code...
    where exception occurs and not
    handled.
    class TestFinallyBlock1{
    public static void main(String args[]){
    try{
    int data=25/0;
    System.out.println(data);
    }
    catch(NullPointerException e){System.out.println(e);}
    finally{System.out.println("finally block is always executed");}
    System.out.println("rest of the code...");
    }
    }
    Test it Now Output:finally block is always executed Exception in
    thread main java.lang.ArithmeticException:/ by zero
    Case 3
    where exception occurs and handled
    public class TestFinallyBlock2{
    public static void main(String args[]){
    try{
    int data=25/0;
    System.out.println(data);
    }
    catch(ArithmeticException e){System.out.println(e);}
    finally{System.out.println("finally block is always executed");}
    System.out.println("rest of the code...");
    }
    }
    Test it Now Output:Exception in thread main
    java.lang.ArithmeticException:/ by zero finally block is always executed
    rest of the code...
    Java throw keyword

    The Java throw keyword is used to explicitly


    throw an exception.
    We can throw either checked or uncheked
    exception in java by throw keyword. The throw
    keyword is mainly used to throw custom
    exception. We will see custom exceptions later.
    The syntax of java throw keyword is given below.
    throw exception;
    Let's see the example of throw IOException.
    throw new IOException("sorry device error);
    java throw keyword example
    In this example, we have created the validate method that takes integer value as a parameter. If the
    age is less than 18, we are throwing the ArithmeticException otherwise print a message welcome
    to vote.
    public class TestThrow1{
    static void validate(int age){
    if(age<18)
    throw new ArithmeticException("not valid");
    else
    System.out.println("welcome to vote");
    }
    public static void main(String args[]){
    validate(13);
    System.out.println("rest of the code...");
    }
    }
    Output:
    Exception in thread main java.lang.ArithmeticException:not valid

    You might also like