Dillon: CSE470: JAVA, EXCEPTIONS & THREADS1 JAVA l Developed at SUN by James Gosling with support...
-
Upload
camilla-todd -
Category
Documents
-
view
218 -
download
1
Transcript of Dillon: CSE470: JAVA, EXCEPTIONS & THREADS1 JAVA l Developed at SUN by James Gosling with support...
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 1
JAVA
Developed at SUN by James Gosling with support from Bill Joy
Net-based language Descended from Oak
» platform independent» object oriented» small
The Java Tutorial: http://java.sun.com/docs/books/tutorial
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 2
Goals for Java
Simple» easy to learn
– based on C/C++
» small
Object oriented» single inheritance
Distributed» libraries supply
protocols
Robuststrongly typedsafe pointer model
SecurePlatform independent
virtual machinePortable
no implementation dependent data types
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 3
Goals for Java (cont.)
Compiled and interpreted Multithreaded Dynamic
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 4
Java Virtual Machine
Compiler translates Java into J-code Stack-based virtual machine (JVM) No undefined or platform specific data types Other languages can be translated to J-code Interpreter is lightweight, easy to implement
» use widely available language, like C
J-code is highly optimized J-code can be compiled on the fly
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 5
How it Works
The JVM may be» an interpreter» an applet viewer» a web browser» part of an OS
Classes could be loaded from filesystem or over a network
JVMs use an environment variable, CLASSPATH, to find byte code (.class files) to execute
Java source
Java compiler (javac)
J-code (JVM byte codes)
Other classes
Native code
Java interpreter
(a JVM)Platform independent
e.g., AWT
Platform dependent
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 6
Java combines benefits of
A strongly typed, OO language Flexibility of an interpreted language
» Lisp, Perl, Tcl
A smalltalk virtual machine with security protection» Java byte code verifier reduces runtime checks
Package structure for organizing classes into subsystems
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 7
Other benefits of Java
Exception handling
Support for multi-threading
» Based on Hoare’s monitors
Highly optimized
» Easy debugging– make debugging statements dependent on a constant
value, which programmer sets when done debugging
– compiler automatically removes unexecutable statements
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 8
Three levels of Security Security manager
» controls access to system resources» highlight windows of untrusted applications
Class loader» restricts classes loaded from network to interact with
classes from the same location Verifier
» checks that incoming classes can’t forge pointers, violate access permissions, over/under flow operator stack, etc.
» ensures type safety
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 9
Java doesn’t have
Macros and preprocessor» mostly used for platform dependencies
Operator overloading, except for + (Very many) automatic type coercions Pointer arithmetic
» references are a higher level type and can only point to class objects, not to class methods
Explicit memory management » provides automatic garbage collection
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 10
Java and the Web
A web browser can incorporate a JVM and run Java applets as executable code
Life of an applet» Loaded by a web browser and asked to initialize
itself» Informed each time it is displayed and hidden» Informed when it is no longer needed
Security manager prevents applet from accessing system resources or interacting with outside applications
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 11
Java classes
Class is the basic computation unit
» encapsulates data and associated operations
» found and loaded dynamically as needed
22 architecture specific classes: “gateway to
the real world”
» networking, windowing, filesystem, etc.
Rest of Java is written in Java
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 12
Inheritance in Java
Single inheritance hierarchy
Multiple inheritance of interfaces
» Interface specifies the operations but not the
implementations
» A class can “implement” multiple interfaces
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 13
Java coding conventions
Class names begin with upper case letters Variables and method names begin with
lower case letters Constants are all upper case Separate words with uppercase letter instead
of underscorese.g. aVariableName AClassName
aMethodName ACONSTANT
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 14
Classes in Java
Define an abstract data type» operations called methods» data called variables or fields
Many class instances or objects can exist» each instance may have a different state
– e.g., different values for variables
» all instances have the same methods
Arranged in a hierarchy» each class has a unique superclass (parent)» subclass (child) can add or modify methods or variables of
the superclass
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 15
Variables in Java
Maintain state of a class instance Belong to some class or class instance
» static variable -- one per class » instance variable -- one per class instance
All variable values are by reference» point to their values, which are maintained on a
heap» Initial value is null» access to null value raises the
NullPointerException exception
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 16
A simple Java applet
import java.applet.Applet;import java.awt.Graphics;
public class Simple extends Applet { StringBuffer buffer;
public void init( ) { buffer = new StringBuffer( ); addItem(“initializing …”); }
public void start( ) { addItem(“starting …”); }
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 17
A simple Java applet (cont.)
public void stop( ) { addItem(“stopping …”); }
public void destroy( ) { addItem(“starting …”); }
public void addItem(String newWord ) { System.out.println(newWord); buffer.append(newWord); repaint( ); }
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 18
A simple Java applet (cont.)
public void paint (Graphics g) { //Draw a rectangle around the applet’s display area g.drawRectangle(0, 0, size( ).width-1, size( ).height-1); //Draw the current string inside the rectangle g.drawString(buffer.toString( ), 5, 15); }
}
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 19
Lifetime of an Applet
running stopped
load/init( );start( );
leave page/stop( )
return to page/start( )
iconify/stop( )
de-iconify/start( )
quit/destroy( )
reload/stop( ); destroy( ); init( )
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 20
Part of the Java Class Hierarchy
Object
Component
ContainerButton
Window Panel
Applet
Simple
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 21
Subclassing and Inheritance
A subclass extends, refines, or specializes a superclass
A subclass can extend only one superclass A subclass inherits the public methods and
variables from its superclass» Does not inherit private members (in Java)
The subclass is considered a subtype of the superclass» All visible superclass operations apply to subclass
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 22
Subclassing Example
Container
WindowPanel
Applet Simple
Container( )add(Component)doLayout( )getComponent(int)
paint(Graphics)print(Graphics)remove(Component) . . .
Panel( )Panel(Layout)addNotify( )
Applet( )init( )start( ) . . .
getImage(URL, String)getParameter(String)play(URL). . .
init( )start( )stop( )destroy ( )paint (Graphics)
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 23
Interfaces in Java
An interface class describes a protocol of behavior» Members are constants and abstract methods» Abstract methods have no implementations
Can be implemented by any class anywhere in the class heirarchy» Cannot be instantiated» Implementing classes agree to implement all methods
declared in the interface» Class can implement multiple interfaces» Interface can be implemented by multiple classes
Does not force a class relationship
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 24
Interface Example
Objects can register themselves with an AlarmClock object to be woken up after some specified time» Objects call the letMeSleepFor method:
public synchronized boolean letMeSleepFor( Sleeper theSleeper, long time){ int index = findNextSlot ( ); if (index == NOROOM) { return false; } else { sleepers[ index ] = theSleeper; sleepFor[ index ] = time; new AlarmThread( index ).start( ); return true; }}
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 25
Interface Example (cont.)
An object that wants to use AlarmClock must implement the wakeUp method» This is enforced by the type of theSleeper
Public interface Sleeper { public void wakeUp ( );
public long ONE_SECOND = 1000; // in milliseconds public long ONE_MINUTE = 60000; // in milliseconds}
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 26
Interface Example (cont.)
Any object that implements this interface can be passed to letMeSleepFor
Class GUIClock extends Applet implements Sleeper { . . . public void wakeUp ( ) { repaint ( ); clock.letMeSleepFor( this, ONE_MINUTE); }}
GUIClock updates its display every minute (showing the current time)
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 27
Abstract class v.s. Interface class
Why not use an abstract class for Sleeper?
Abstract class Sleeper { public abstract void wakeUp ( );}
Only objects that are subclasses of Sleeper would be able to use AlarmClockConceptually, AlarmClock should not force a class relationship on its users
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 28
Exceptional Conditions
Handling exceptional conditions can more than double the size of the code
Systems can respond to errors in many ways» crash» give error message and crash» give error message and let user retry
– minimize work that must be redone– allow user to decide how much work must be redone
» correct the error– allow user to confirm that correction is valid
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 29
Approaches for Handling Exceptional Conditions
Each method handles the exceptional conditions that arise during its execution
A low level class/method handles all exceptional conditions that may arise
All methods return status information so that client methods can respond to exceptional conditions
ALL OF THESE APPROACHES HAVE PROBLEMS
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 30
I. Each method handles its own exceptional conditions
info1(in case an exception arises)
info1, info2(in case an exception arises)
Code to detect and handle exception
Code to detect and handle exception (use info1, info2)
Code to detect and handle exception (use info1)
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 31
I. Each method handles its own exceptional conditions
No modularity or consistency» changes to error handling affect all the methods
May need to pass considerable information many levels to maintain context information» hard to provide user friendly response w/o
knowing clients context
Must return status information so calling method can determine if it should proceed or terminate
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 32
II. A low level class/method handles exceptional conditions
Exception handling class
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 33
II. A low level class/method handles exceptional conditions
Error processing handled in a more consistent and modular fashion» changes to error handling only affect the error handling
class/method
May need to pass considerable information many levels to maintain context information» hard to provide user friendly response w/o knowing clients
context
Must return status information so calling method can determine if it should proceed or terminate
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 34
III. Methods return status information so that client methods can respond to
exceptional conditions
Calling method must always check status information
Calling methods must be able to respond to status information
call Foo(bar, status1, status2, …, statusN);if status1 then do repair1;else if status2 then do repair2;else if . . .else normal processing using barendif
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 35
Exceptions were added to languages to help with error processing
A method that detects a problem can handle the exception locally and then raise/throw/signal an exception to the methods in its calling context
throw E1
handler for E1
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 36
A method can catch an exception and specialize its response
throw E1
handler for E2
handler for E1;throw E2
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 37
Exception Handling Mechanisms
Signal/raise/throw an exception» predefined» user defined
Exception handlers» local» non-local
– propagate through call stack– one level only– multiple levels
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 38
Exception Handling Mechanisms (cont.)
Execution after handler
» resumption model: return to signal location
» termination model: terminate execution of method
Java supports predefined and user defined
exceptions, local and multi-level propagation,
with termination
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 39
Exceptions in Java
Indicates an unusual situation (error) Thrown at the point in the code where the
error occurs Caught by an exception handler
» Can be handled locally» Can look back through call stack for the first
handler
Methods must declare the exceptions they throw
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 40
Handling Exceptions
try{ i = s.pop( );}
catch( EmptyStackException i);
{ system.out.println( “Oops! The stack is empty!” ); i = 0;}
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 41
Handling multiple exceptions
try{ readFromFile( “foo” );}catch( FileNotFoundException e);{ system.out.println( “Oops! The file is missing!” );}catch( IOException e ){ system.out.println( “Oops! Can’t read the file!” );}finally{ readFromFile( “foo.bak”);}
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 42
Try/Catch Statement
Exceptions raised in the try body are handled in the catch statements
Catch statements are evaluated in order» first match leads to execution of the catch body
Usually list exceptions from most specific to least specific
If there is a finally clause then it is always executed May not execute all statements in try body
» could be interrupted by an exception
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 43
Finding Exception Handlers
Look in enclosing blocks Look in calling methods If no exception handler is found in call stack, program
crashes
throw E1
handler for E1
propagate E1
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 44
Multiple Levels of Propagation
getContent( _){ try { openConection( ); readData ( ); } catch (IOException e) { //handle IO error }}openConnection ( ) throws IOException{ openSocket( ); sendRequest( ); ….}sendRequest ( ) throws IOException{ write (body); //write error}
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 45
Explanation
Write throws the exception
sendRequest doesn’t handle the exception but must
indicate that it propagates the exception
Same for openConnection
getContent catch statement handles the exception
May never execute the readData( ) statement in
getContent
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 46
Throwing Exceptions
int Dequeue (Queue q) throws QueueEmpty{ if ( q.head == q.tail ) { throw new QueueEmpty ( ); } else { q.head = q.head + 1; return q.contents [q.head - 1]; }}
class QueueEmpty extends Exception{}
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 47
Types of Java Exceptions
General exceptions» Must be explicitly thrown
» Should be handled by all programs
Runtime exceptions» Frequent runtime problems
» No need to explicitly state that such an exception might be thrown
» Runtime message generated if they are not caught
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 48
Summary of Exception Handling
Exceptions allow the programmer to separate the
handling of unusual cases from expected ones
Program should catch predefined exceptions and
throw more specific exceptions when possible
Exception handling is difficult, even with exception
handlers
Exception handling is an important part of most
programs
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 49
Concurrent System
Multiple threads of execution» Logically concurrent: share a single processor
» Physically concurrent: multiple processors
Run independently, for the most part Typically, need to communicate
» Share data
» Pass messages
Typically, need to synchronize their activities
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 50
Threads in Java
A thread is a sequential flow of control within a program» has a beginning, an execution sequence, and an end» cannot be run on its own, but exists only within a larger
program
A program with three threads
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 51
Defining the behavior of a thread
The behavior of a thread in Java is given by
a special method
» the run method
Two techniques for providing a run method
for a thread
» Subclass Thread and override the run method
» Implement the Runnable interface
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 52
Defining thread behavior: Subclassing Thread
A thread that computes names larger than a given value
class PrimeThread extends Thread { long minPrime; PrimeThread ( long minPrime ) { this.minPrime = minPrime; } public void run ( ) { // compute primes larger than minPrime . . . }}
Code to create a PrimeThread thread and start running it:
PrimeThread p = new PrimeThread(143);p.start ( );
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 53
Defining thread behavior: Implementing runnable
class PrimeRun implements Runnable { long minPrime; PrimeRun ( long minPrime ) { this.minPrime = minPrime; } public void run ( ) { // compute primes larger than minPrime . . . }}
Code to create a PrimeThread thread and start running it:
PrimeRun p = new PrimeRun(143);new Thread( p ).start ( );
A thread that computes names larger than a given value
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 54
When should you implement Runnable?
If a class needs its own thread and must
subclass some other class, you should
implement Runnable
» Example: Suppose you want an applet that
displays the time, updating it every second– It has to subclass Applet to run in a browser
– It needs its own thread in order to continuously update its
display without taking over the process that its running in
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 55
Life Cycle of a Thread in Java
newnew Thread ( . . . )
running
start ( )
executing
waiting
not runnable
stopped
run method terminates
Transitions to not runnable» invokes its sleep method
» invokes a wait method for some condition
» blocks on an IO operation
Transitions to running» specified time elapses
» notify method is invoked to signify the condition is met
» the IO operation completes
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 56
Synchronizing Threads in Java
A lock is associated with objects containing synchronized methods» The object is locked when a thread enters one of
its synchronized methods
» Other threads cannot enter a synchronized method on the same object until the object is unlocked
Lock is acquired and released automatically by the Java Runtime System
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 57
Synchronizing Threads in Java (cont.)
Threads that use synchronized methods are coordinated using wait and notify (or notifyAll)
» Invoking the wait method blocks the thread and releases the lock
» An object invokes notify to wake up a thread that is waiting on it
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 58
Producer/Consumer Example
public class CubbyHole { private int contents; private boolean available = false;
public synchronized int put ( ) { //CubbyHole is locked by the Producer . . . //CubbyHole is unlocked by the Producer }
public synchronized int get ( ) { //CubbyHole is locked by the Consumer . . . //CubbyHole is unlocked by the Consumer }}
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 59
Producer/Consumer Example (cont.)
public synchronized int get ( ) { while ( available == false ) { try { // wait for Producer to put value wait ( ); } catch ( InterruptedException e) { } } available = false; // notify Producer that value has been retrieved notifyAll ( ); return contents;}
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 60
Producer/Consumer Example (cont.)
public synchronized void put ( int value ) { while ( available == true ) { try { // wait for Consumer to get value wait ( ); } catch ( InterruptedException e) { } } contents = value; available = true; // notify Consumer that value has been set notifyAll ( );}
Dillon: CSE470: JAVA, EXCEPTIONS & THREADS 61
Concurrency Summary
A thread is a sequential flow of control
Multiple threads execute concurrently within
the same program
Objects with synchronized methods
implement monitors
» monitors use the wait and notify methods to
coordinate the activities of the threads that they
serve