1 lecture 11(chap 14) exception handling & thread instructors: fu-chiung cheng ( 鄭福炯 )...
Post on 13-Jan-2016
224 Views
Preview:
TRANSCRIPT
1
Lecture 11(chap 14)Exception Handling & Thread
Instructors:
Fu-Chiung Cheng
(鄭福炯 )
Associate Professor
Computer Science & Engineering
Tatung Institute of Technology
1
Outline
• exception processing
• catching and handling exceptions
• creating new exceptions
• separate process threads
• synchronizing threads
2
Exceptions
• An exception is an object that describes an unusual or erroneous situation
• Exceptions are thrown by a program, and may be caught and handled by another part of the program
• A program can therefore be separated into a normal execution flow and an exception execution flow
• An error is also represented as an object in Java, but usually represents a unrecoverable situation and should not be caught
3
Exception Handling
• A program can deal with an exception in one of three ways:– ignore it– handle it where it occurs– handle it an another place in the program
• The manner in which an exception is processed is an important design consideration
4
Exception Handling
• If an exception is ignored by the program, the program will terminate and produce an appropriate message
• The message includes a call stack trace that indicates on which line the exception occurred
• The call stack trace also shows the method call trail that lead to the execution of the offending line
• See Zero.java
public class Zero { public static void main (String[] args) { int numerator = 10; int denominator = 0; System.out.println (numerator / denominator); } // method main} // class Zero
5
The try Statement
• To process an exception when it occurs, the line that throws the exception is executed within a try block
• A try block is followed by one or more catch clauses, which contain code to process an exception
• Each catch clause has an associated exception type• When an exception occurs, processing continues at t
he first catch clause that matches the exception type• See Adding.java
import java.io.*;public class Adding { public static void main (String[] args) { int num1 = User_Reader.get_integer
("Enter a number: "); int num2 = User_Reader.get_integer
("Enter another number: "); System.out.println ("The sum is " + (num1+num2)); } // method main} // class Addingclass User_Reader { public static int get_integer (String prompt) { BufferedReader stdin = new BufferedReader (new InputStreamReader(System.in)); int number = 0; boolean valid = false;
while (! valid) { System.out.print (prompt); System.out.flush (); try { number = Integer.parseInt (stdin.readLine()); valid = true; } catch (NumberFormatException exception) { System.out.println ("Invalid input. Try again."); } catch (IOException exception) { System.out.println ("Input problem. Terminating."); System.exit(0); } } return number; } // method get_integer} // class User_Reader
6
Exception Propagation
• If it is not appropriate to handle the exception where it occurs, it can be handled at a higher level
• Exceptions propagate up through the method calling hierarchy until they are caught and handled or until they reach the outermost level
• A try block that contains a call to a method in which an exception is thrown can be used to catch that exception
• See Propagation_Demo.java
public class Propagation_Demo { static public void main (String[] args) { Exception_Scope demo = new Exception_Scope(); System.out.println("program beginning"); demo.level1(); System.out.println("program ending"); } // method main} // class Propagation_Democlass Exception_Scope { public void level3 (int adjustment) { int current = 1; System.out.println("level3 beginning"); current = current / adjustment; // divided by zero System.out.println("level3 ending"); } // method level3
public void level2() { System.out.println("level2 beginning"); level3 (0); System.out.println("level2 ending"); } // method level2 public void level1() { System.out.println("level1 beginning"); try { level2(); } catch (ArithmeticException problem) { // page 667 System.out.println (problem.getMessage()); problem.printStackTrace(); } System.out.println("level1 ending"); } // method level1} // class Exception_Scope
7
Exceptions
• An exception is either checked or unchecked• A checked exception can only be thrown within a
try block or within a method that is designated to throw that exception
• The compiler will complain if a checked exception is not handled appropriately
• An unchecked exception does not require explicit handling, though it could be processed that way
8
The throw Statement
• A programmer can define an exception by extending the appropriate class
• Exceptions are thrown using the throw statement:
throw exception-object;
• See Throw_Demo.java • Usually a throw statement is nested inside an if state
ment that evaluates the condition to see if the exception should be thrown
import java.io.IOException;public class Throw_Demo { public static void main (String[] args) throws Ooops { Ooops problem = new Ooops ("Alert!"); throw problem; // execution never gets to this point } // method main} // class Throw_Demo
class Ooops extends IOException { Ooops (String message) { super (message); } // constructor Ooops
} // class Ooops
9
The finally Clause
• A try statement can have an optional clause designated by the reserved word finally
• If no exception is generated, the statements in the finally clause are executed after the statements in the try block complete
• Also, if an exception is generated, the statements in the finally clause are executed after the statements in the appropriate catch clause complete
9
The finally Clause
• Exception Handling:
try {
code that may generate exception;
} catch (exception) {
code to handle the exception;
} finally {
code will be executed;
}
10
Threads
• Processing can be broken into several separate threads of control which execute at the same time
• "At the same time" could mean true parallelism or simply interlaced concurrent processing
• A thread is one sequential flow of execution that occurs at the same time another thread is executing the statement of the same program
• They are not necessarily executing the same statements at the same time
11
Threads
• A thread can be created by deriving a new thread from the Thread class
• The run method of the thread defines the concurrent activity, but the start method is used to begin the separate thread process
• See Simultaneous.java• A thread can also be created by defining a class that imp
lements the Runnable interface• By implementing the interface, the thread class can be d
erived from a class other than Thread
public class Simultaneous { public static void main (String[] args) { Soda one = new Soda ("Coke"); Soda two = new Soda ("Pepsi"); Soda three = new Soda ("Diet Coke"); one.start(); two.start(); three.start(); } // method main} // class Simultaneousclass Soda extends Thread { private String name; Soda (String str) { name = str; } // constructor Soda public void run() { for (int count = 0; count < 100; count++) System.out.println (name); } // method run} // class Soda
12
Shared Data
• Potential problems arise when multiple threads share data
• Specific code of a thread may execute at any point relative to the processing of another thread
• If that code updates or references the shared data, unintended processing sequences can occur that result in incorrect results
13
Shared Data
• Consider two withdrawals from the same bank account at the same time
task: withdraw 300
Is amount <= balance
YES
balance -= 300
balance
531
231
-69
task: withdraw 300
Is amount <= balance
YES
balance -= 300
14
Synchronization
• Multiple threads of control can be made safe if areas of code that use shared data are synchronized
• When a set of code is synchronized, then only one thread can be using that code at a time
• The other threads must wait until the first thread is complete
• This is an implementation of a synchronization mechanism called a monitor
• See ATM_Accounts.java
public class ATM_Accounts { public static void main (String[] args) { Savings_Account savings =
new Savings_Account(4321, 531); ATM west_branch = new ATM (savings); ATM east_branch = new ATM (savings); west_branch.start(); east_branch.start(); } } // class ATM_Accountsclass Savings_Account { protected int account; protected int balance; public Savings_Account (int account_num, int initial) { account = account_num; balance = initial; } // constructor Savings_Account
public synchronized boolean withdrawal (int amount) { boolean result = false; System.out.println ("Withdrawal from account "
+ account); System.out.println ("Amount: " + amount); if (amount <= balance) { balance -= amount; System.out.println ("New balance: " + balance); result = true; } else System.out.println ("Insufficient funds."); System.out.println(); return result; } // method withdrawal} // class Savings_Account
class ATM extends Thread { Savings_Account account; ATM (Savings_Account savings) { account = savings; } // constructor ATM public void run () { account.withdrawal (300); } // method run} // class ATM
Thread Synchronization
• synchronized statement: synchronized (expr) statement;
15
Controlling Threads
• Thread processing can be temporarily suspended, then later resumed, using methods from the Thread class
• A thread can also be put to sleep for a specific amount of time
• These mechanisms can be quite helpful in certain situations, like controlling animations
• See Bouncing_Ball2.java
import java.awt.event.*;import java.applet.Applet;import java.awt.*;public class Bouncing_Ball2 extends Applet { private final int SIZE = 300; private Ball ball = new Ball(150, 10, 250, 200); private Graphics page; private Control_Panel controls; public void init() { setVisible(true); setSize(SIZE, SIZE); page=getGraphics(); page.setXORMode (getBackground()); } // method init public void start() { controls = new Control_Panel (Thread.currentThread()); controls.start(); ball.pause(); while (ball.moving()) ball.bounce (page); } // method start} // class Bouncing_Ball2
class Control_Panel extends Thread { private Button suspend = new Button ("suspend"); private Button resume = new Button ("resume"); private Frame frame = new Frame ("B B Control Panel"); private Thread applet_thread; Control_Panel (Thread applet_thread) { this.applet_thread = applet_thread; } // constructor Control_Panel public void run() { Resume_Action resume_action =
new Resume_Action (applet_thread); Suspend_Action suspend_action =
new Suspend_Action (applet_thread); suspend.addActionListener (suspend_action); resume.addActionListener (resume_action); frame.setLayout (new FlowLayout()); frame.add (suspend); frame.add (resume); frame.pack(); frame.setLocation (250, 200); frame.setVisible (true); } } // class Control_Panel
class Suspend_Action implements ActionListener {
Thread applet_thread; Suspend_Action (Thread applet_thread) { this.applet_thread = applet_thread; } // constructor Suspend_Action public void actionPerformed(ActionEvent action) { applet_thread.suspend(); } // method actionPerformed
} // class Suspend_Action
class Resume_Action implements ActionListener {
Thread applet_thread; Resume_Action (Thread applet_thread) { this.applet_thread = applet_thread; } // constructor Resume_Action
public void actionPerformed(ActionEvent action) { applet_thread.resume(); } // method actionPerformed
} // class Resume_Action
class Ball { private final int MOVE = 2; private final float DISTANCE = 0.97f; private final int SIZE = 20; private final int PAUSE = 5; private int x; private int start_y; private int end_y; private int length; private boolean moving_up = true; Ball (int new_x, int new_start_y, int new_end_y,
int new_length) { x = new_x; start_y = new_start_y; end_y = new_end_y; length = new_length; } // constructor Ball public void pause() { try { Thread.currentThread().sleep (PAUSE); } catch (InterruptedException exception) { System.out.println ("have an exception"); } } // method pause
void move() { if (moving_up) end_y = end_y - MOVE; else end_y = end_y + MOVE; } // method move
void draw_ball (Graphics page) { page.drawOval (x-(SIZE/2), end_y, SIZE, SIZE); page.drawLine (x, start_y, x, end_y); } // draw_ball
public boolean moving () { return length != 0; } // method moving
public void bounce (Graphics page) {
for (int count = 1; count < length; count += MOVE) { draw_ball(page); pause(); // for loop in previous example draw_ball(page); move(); }
moving_up = !moving_up; length = (int) (DISTANCE * length);
} // method bounce
} // class Ball
Conclusion
• Exception handling make a program to separate to a normal execution flow and an exception execution flow• Programmers must carefully consider how exception• should be handled.• Threads: created by A. inheriting from Thread class B. implementing Runnable interface• Synchronization may be used to prevent concurrent access shared data.
top related