Post on 31-Dec-2015
Agenda of Today
2
Introduction Thread Applications Defining Threads Java Threads and States
• Priorities Accessing Shared Resources
• Synchronisation Advanced Issues:
• Concurrency Models: master/worker, pipeline, peer processing
Serialization Reflection Java Beans
A single threaded program
3
class ABC
{
….public void main(..)
{
…
..
}
}
begin
body
end
A Multithreaded Program
4
Main Thread
Thread A Thread B Thread C
start startstart
Threads may switch or exchange data/results
Single and Multithreaded Processes
5
Single-threaded Process
Single instruction stream Multiple instruction stream
Multiplethreaded ProcessThreads of
Execution
CommonAddress Space
threads are light-weight processes within a process
Multithreaded Server: For Serving Multiple Clients Concurrently
6
ServerThreads
Server ProcessClient 1 Process
Client 2 Process
Internet
Web/Internet Applications:Serving Many Users Simultaneously
7
Internet Server
PC client
Local Area Network
PDA
Multithreaded Applications Modern Applications need Threads (ex1): Editing and Printing documents in background.
Printing ThreadPrinting Thread
Editing ThreadEditing Thread
Multithreaded/Parallel File Copy
9 9
reader(){
- - - - - - - - - -lock(buff[i]);read(src,buff[i]);unlock(buff[i]);- - - - - - - - - -}
reader(){
- - - - - - - - - -lock(buff[i]);read(src,buff[i]);unlock(buff[i]);- - - - - - - - - -}
writer(){
- - - - - - - - - -lock(buff[i]);write(src,buff[i]);unlock(buff[i]);- - - - - - - - - -}
writer(){
- - - - - - - - - -lock(buff[i]);write(src,buff[i]);unlock(buff[i]);- - - - - - - - - -}
buff[0]buff[0]
buff[1]buff[1]
Cooperative Parallel Synchronized Threads
Cooperative Parallel Synchronized Threads
What are Threads?
10
A piece of code that runs in concurrent with other threads.
Each thread is a statically ordered sequence of instructions.
Threads are being extensively used to express concurrency on both single and multiprocessors machines.
Programming a task having multiple threads of control – Multithreading or Multithreaded Programming.
Java Threads
11
Java has built in thread support for Multithreading• Synchronization • Thread Scheduling• Inter-Thread Communication:
• currentThread start setPriority• yield run getPriority• sleep stop suspend• resume
Java Garbage Collector is a low-priority thread.
Threading Mechanisms...
12
Create a class that extends the Thread classCreate a class that implements the Runnable
interface
Thread
MyThread
Runnable
MyClass
Thread
(objects are threads) (objects with run() body)
[a] [b]
1st method: Extending Thread class
13
Create a class by extending Thread class and override run() method: class MyThread extends Thread {
public void run() { // thread body of execution } } Create a thread: MyThread thr1 = new MyThread(); Start Execution of threads: thr1.start(); Create and Execute: new MyThread().start();
An example
14
class MyThread extends Thread { public void run() { System.out.println(" this thread is running ... "); }}
class ThreadEx1 { public static void main(String [] args ) {
MyThread t = new MyThread(); t.start();
}}
2nd method: Threads by implementing Runnable interface
15
Create a class that implements the interface Runnable and override run() method:
class MyThread implements Runnable{ ..... public void run() { // thread body of execution }} Creating Object: MyThread myObject = new MyThread(); Creating Thread Object: Thread thr1 = new Thread( myObject ); Start Execution: thr1.start();
An example
16
class MyThread implements Runnable { public void run() { System.out.println(" this thread is running ... "); }}
class ThreadEx2 { public static void main(String [] args ) { Thread t = new Thread(new MyThread()); t.start(); } }
Life Cycle of Thread
17
new
ready
start()
running
deadstop()
dispatch
completion
wait()
waitingsleeping blocked
notify()
sleep()
Block on I/O
I/O completed
Time expired/interrupted
suspend()
resume()
A Program with Three Java Threads
18
Write a program that creates 3 threads
Three threads example
19
class A extends Thread { public void run() { for(int i=1;i<=5;i++) { System.out.println("\t From ThreadA: i= "+i); } System.out.println("Exit from A"); } }
class B extends Thread { public void run() { for(int j=1;j<=5;j++) { System.out.println("\t From ThreadB: j= "+j); } System.out.println("Exit from B"); } }
20
class C extends Thread { public void run() { for(int k=1;k<=5;k++) { System.out.println("\t From ThreadC: k= "+k); }
System.out.println("Exit from C"); } }
class ThreadTest { public static void main(String args[]) { new A().start(); new B().start(); new C().start(); } }
Run 1
21
threads [1:76] java ThreadTest From ThreadA: i= 1 From ThreadA: i= 2 From ThreadA: i= 3 From ThreadA: i= 4 From ThreadA: i= 5Exit from A From ThreadC: k= 1 From ThreadC: k= 2 From ThreadC: k= 3 From ThreadC: k= 4 From ThreadC: k= 5Exit from C From ThreadB: j= 1 From ThreadB: j= 2 From ThreadB: j= 3 From ThreadB: j= 4 From ThreadB: j= 5Exit from B
Run2
22
threads [1:77] java ThreadTest From ThreadA: i= 1 From ThreadA: i= 2 From ThreadA: i= 3 From ThreadA: i= 4 From ThreadA: i= 5 From ThreadC: k= 1 From ThreadC: k= 2 From ThreadC: k= 3 From ThreadC: k= 4 From ThreadC: k= 5Exit from C From ThreadB: j= 1 From ThreadB: j= 2 From ThreadB: j= 3 From ThreadB: j= 4 From ThreadB: j= 5Exit from BExit from A
Thread Priority
23
In Java, each thread is assigned priority, which affects the order in which it is scheduled for running. The threads so far had same default priority (NORM_PRIORITY) and they are served using FCFS policy.• Java allows users to change priority:
• ThreadName.setPriority(intNumber)• MIN_PRIORITY = 1• NORM_PRIORITY=5• MAX_PRIORITY=10
Accessing Shared Resources
24
Applications Access to Shared Resources need to be coordinated.• Printer (two person jobs cannot be printed at the
same time)• Simultaneous operations on your bank account. • Can the following operations be done at the same
time on the same account?• Deposit()• Withdraw()• Enquire()
Online Bank: Serving Many Customers and Operations
25
Internet Bank Server
PC client
Local Area Network
PDABankDatabase
26
Shared Resources
27
If one thread tries to read the data and other thread tries to update the same data, it leads to inconsistent state.
This can be prevented by synchronising access to the data.
Use “Synchronized” method: • public synchronized void update()• {
• …
• }
the driver: 3rd Threads sharing the same object
28
class InternetBankingSystem { public static void main(String [] args ) { Account accountObject = new Account (); Thread t1 = new Thread(new MyThread(accountObject)); Thread t2 = new Thread(new YourThread(accountObject)); Thread t3 = new Thread(new HerThread(accountObject));
t1.start(); t2.start(); t3.start(); // DO some other operation } // end main()}
Shared account object between 3 threads
29
class MyThread implements Runnable { Account account; public MyThread (Account s) { account = s;} public void run() { account.deposit(); }} // end class MyThread
class YourThread implements Runnable { Account account; public YourThread (Account s) { account = s;} public void run() { account.withdraw(); } } // end class YourThread
class HerThread implements Runnable { Account account; public HerThread (Account s) { account = s; } public void run() {account.enquire(); }} // end class HerThread
account(shared object)
Monitor (shared object access): serializes operation on shared
object
30
class Account { // the 'monitor' int balance;
// if 'synchronized' is removed, the outcome is unpredictable public synchronized void deposit( ) { // METHOD BODY : balance += deposit_amount; }
public synchronized void withdraw( ) { // METHOD BODY: balance -= deposit_amount;
} public synchronized void enquire( ) {
// METHOD BODY: display balance. }
}
Thread concurrency/operation models
31
The master/worker model The peer model A thread pipeline
The master/worker model
32
taskXtaskX
taskYtaskY
taskZtaskZ
main ( )main ( )
WorkersProgram
Files
Resources
Databases
Disks
SpecialDevices
Master
Input (Stream)
The peer model
33
taskXtaskX
taskYtaskY
WorkersProgram
Files
Resources
Databases
Disks
SpecialDevices
taskZtaskZ
InputInput
A thread pipeline
34
Resources Files
Databases
Disks
Special Devices
Files
Databases
Disks
Special Devices
Files
Databases
Disks
Special Devices
Stage 1Stage 1 Stage 2Stage 2 Stage 3Stage 3
Program Filter Threads
Input (Stream)
35
Effective Java
36
Item 8
Obey the general contract when overriding equals()
Overriding seems simple, but there are many ways to get it wrong.
Best approach – Avoid! Works if:• Each instance of a class is unique• You don’t care if class has logical equality• The superclass equals is satisfactory• Class is not public and equals never used
General contract for equals Reflexive
• x.equals(x) must be true Symmetric
• x.equals(y) iff y.equals(x) Transitive
• If x.equals(y) && y.equals(z) • Then x.equals(z)
Consistency… Null values:
• x.equals(null) is always false
How hard could this be? Reflexivity is pretty much automatic Symmetry is not:
• Example CaseInsensitiveString
private String s;// Broken – violates symmetry@Override public boolean equals (Object o) { if (o instanceof CaseInsensitiveString) return s.equalsIgnoreCase( ((CaseInsensitiveString) o).s); if (o instance of String) // Not Symmetric! return s.equalsIgnoreCase((String) o); return false;}
Why does this violate symmetry?
Consider this code: Object x = new CaseInsenstiveString (“abc”); Object y = “Abc”; // y is a String if (x.equals(y)) {…} // evaluates true, so execute if (y.equals(x)) {…} // evaluates false, so don’t…
Dispatching of equals() calls• First equals() call to CaseInsensitiveString• Second equals() call to String
This is horrible!
Correct Implementation
Avoid temptation to be “compatible” with the String class:
// CaseInsensitiveString is not a subclass of String!private String s;@Override public boolean equals (Object o) { return (o instanceof CaseInsensitiveString) && (CaseInsensitiveString o).s. equalsIgnoreCase(s);}
Symmetry and Transitivity
Surprisingly difficult – general result about inheritance
Example: • A 2D Point class
• State is two integer values x and y• equals() simply compares x and y values
• An extension to include color• public class ColorPoint extends Point• What should equals() do?
Preliminaries: What does equals in Point look like?
public class Point { // routine code private int x; private int y; ... @Override public boolean equals(Object o) { if (!(o instanceof Point)) return false; Point p = (Point) o; return p.x == x && p.y == y; }}
Choice 1 for equals() in ColorPoint
Have equals() return true iff the other point is also a ColorPoint:
// Broken – violates symmetry @Override public boolean equals(Object o) { if (!(o instanceof ColorPoint)) return false; ColorPoint cp = (ColorPoint) o; return super.equals(o) && cp.color == color; }
Problem
Symmetry is broken Different results if comparing:
ColorPoint cp = new ColorPoint (1, 2, RED);Point p = new Point (1,2);// p.equals(cp), cp.equals(p) differ
Unfortunately, equals() in Point doesn’t know about ColorPoints • Nor should it…
So, try a different approach…
Choice 2 for equals() in ColorPoint
Have equals() ignore color when doing “mixed” comparisons:
// Broken – violates transitivity @Override public boolean equals(Object o) { if (!(o instance of Point)) return false; // If o is a normal Point, be colorblind if (!o instanceof ColorPoint) return o.equals(this); ColorPoint cp = (ColorPoint o); return super.equals(o) && cp.color == color; }
Now symmetric, but not transitive!
Consider the following exampleColorPoint p1 = new ColorPoint(1,2,RED);Point p2 = new Point(1,2);ColorPoint p3 = new ColorPoint(1,2,BLUE);
The following are true:• p1.equals(p2)• p2.equals(p3)
But not p1.equals(p3)!
The real lesson
There is no way to extend an instantiable class and add an aspect while preserving the equals contract.• Note that abstract superclass definitions of equals()
are fine. (See Bloch Item 20) Wow! Inheritance is hard! Solution: Favor composition over inheritance
(Item 16). Note: This was not well understood when some
Java libraries were built…
How to implement equals()
Use == to see if argument is a reference to this (optimization)
Use instanceof to check if argument is of the correct type (properly handles null)
Cast the argument to the correct type Check each “significant” field Check reflexivity, symmetry, transitivity
Java Serialization
50
So you want to save your data…
51
Common problem:• You’ve built a large, complex object
• Spam/Normal statistics tables• Game state• Database of student records• Etc…
• Want to store on disk and retrieve later• Or: want to send over network to another Java process
In general: want your objects to be persistent
Answer 1
52
You’ve got file I/O nailed, so… Write a set of methods for saving/loading each
class that you care aboutpublic class MyClass { public void saveYourself(Writer o) throws IOException { … } public static MyClass loadYourself(Reader r) throws IOException { … }}
Coolnesses of Approach 1
53
Can produce arbitrary file formats Know exactly what you want to store and get back/don’t store
extraneous stuff Can build file formats to interface w/ other codes/programs
• XML• Tab-delimited/spreadsheet• Etc.
If your classes are nicely hierarchical, makes saving/loading simple
Saving/Loading Recursive Data Structs
54
public interface Saveable { // implemented by many classes public void saveYourself(Writer w) throws IOException; // should also have this // public static Object loadYourself(Reader r) // throws IOException;
// but you can’t put a static method in an // interface in Java}
Painfulnesses of Approach 1
55
This is called recursive descent parsing (and formatting)
If all you want to do is store/retrieve data, do you really need to go to all of that effort?
Fortunately, no. Java provides a shortcut that takes a lot of the work out.
Approach 2: Using Databases
56
Most Client-Server applications use a RDBMS as their data store while using an object-oriented programming language for development
Objects must be mapped to tables in the database and vice versa
Applications generally require the use of SQL statements embedded in another programming language
“Impedance mismatch”
Approach 3: Enter Serialization...
57
Serialization is the process of transforming an in-memory object to a byte stream.
Deserialization is the inverse process of reconstructing an object from a byte stream to the same state in which the object was previously serialized.
“Serializing out” and “serializing in” are also used.
Serialization basics
58
The requirements for serialization are straightforward:• Only class instances rather than primitive types can be
serialized.• For an object to be serializable, its class or some
ancestor must implement the empty Serializable interface.
• An empty interface is called a marker interface.
Serialization basics
59
The syntax for serialization is straightforward:• An object is serialized by writing it to an
ObjectOutputStream.
• An object is deserialized by reading it from an ObjectInputStream.
Serialization code
60
FileOutputStream out = new FileOutputStream( “save.ser” ); ObjectOutputStream oos = new ObjectOutputStream( out ); oos.writeObject( new Date() ); oos.close();
Deserialization code
61
FileInputStream in = new FileInputStream( “save.ser” ); ObjectInputStream ois = new ObjectInputStream( in ); Date d = (Date) ois.readObject(); ois.close();
Things that you don’t want to save
62
Sometimes, you want to explicitly not store some non-static data• Computed values that are cached simply for
convenience/speed• Passwords or other “secret” data that shouldn’t be written to
disk Java provides the “transient” keyword. transient
foo==don’t save foo
public class MyClass implements Serializable { private int _primaryVal=3; // is serialized private transient int _cachedVal=_primaryVal*2; // _cachedVal is not serialized}
Graphs Serialization works by examining the variables of an object and
writing primitives datatypes like numbers and characters to a byte stream.
It also caters to the situation where an object is inside another object.
If an object has a reference to an object which has a reference to another object, they are all saved together.
The set of all objects referenced is called a graph of objects and object serialization converts entire graphs to byte form.
Graphs
Vector
Object i Object n
OutputStream
1010100101
…
Gotchas: #1 -- Efficiency For tables , it is not necessarily efficient, and may even
be wrong By default, Java will store the entire internal _table,
including all of its null entries! Now you’re wasting space/time to load/save all those
empty cells Plus, the hashCode()s of the keys may not be the same
after deserialziation -- should explicitly rehash them to check.
Gotchas: #2 -- Backward compatibility
Suppose that you have two versions of class Foo: Foo v. 1.0 and Foo v. 1.1
The public and protected members of 1.0 and 1.1 are the same; the semantics of both are the same
So Foo 1.0 and 1.1 should behave the same and be interchangable
BUT... The private fields and implementation of 1.0 and 1.1 are different
What happens if you serialize with a 1.0 object and deserialize with a 1.1? Or vice versa?
Backward compat, cont’d. Issue is that in code, only changes to the public or
protected interfaces matter With serialization, all of a sudden, the private data
members (and methods) count too Have to be very careful to not muck up internals in
a way that’s inconsistent with previous versions E.g., changing the meaning, but not name of some
data field
Backward compat, cont’d Example:
// version 1.0public class MyClass { MyClass(int arg) { _dat=arg*2; } private int _dat;}
// version 1.1public class MyClass { MyClass(int arg) { _dat=arg*3; } // NO-NO! private int _dat;}
Backward compat, cont’d:
Java helps as much as it can Java tracks a “version number” of a class that changes when the
class changes “substantially”• Fields changed to/from static or transient• Field or method names changed• Data types change• Class moves up or down in the class hierarchy
Trying to deserialize a class of a different version than the one currently in memory throws InvalidClassException
70
71
Java Reflection
What is Reflection
Reflection: the process by which a program can observe and modify its own structure and behavior at runtime.
Based on RTTI (Run-Time Type Identification):• RTTI: allows programs to discover at runtime and use at runtime
types that were not known at their compile time• Non-RTTI / Traditional approaches:
• assume all types are known at compile time • Polymorphism in OO languages: is a particular case of very limited
RTTI
Kinds of tasks specific to Reflection Inspection: analyzing objects and types to gather information
about their definition and behavior.• Find the run-time type information of an object• Find information about a type (supertypes, interfaces, members)
• Dynamic type discovery
Manipulation: uses the information gained through inspection to change the structure/behavior:• create new instances of new types discovered at runtime • dynamically invoke discovered methods
• Late binding: the types and methods used by a program are not known at compile-time
• The most one could imagine to do in a reflective language: restructure types and objects on the fly !
How is Reflection implemented
Reflective capabilities need special support in language and compiler !• Java: java.lang.reflection
• .NET: System.Reflection
Reflection case study: Reflection in Java
Class java.lang.reflect.Class• It is the entry point for all of the Reflection API
• For each new class in a program a “Class” object is created.
• Provides methods to examine the runtime properties of the object including its members and type information.
• Provides the ability to create new objects of this type.
The Reflection Logical Hierarchy in Java
Class
Field
Method
Constructor
Object
compiled classfile
Member
Retrieving a Class object Object.getClass(): If an instance of an object is available, then the simplest
way to get its Class is to invoke Object.getClass(). Class c = "foo".getClass();
.class: If the type is available but there is no instance then it is possible to obtain a Class by appending ".class" to the name of the type. This is also the easiest way to obtain the Class for a primitive type. boolean b; Class c = b.getClass(); // compile-time error Class c = boolean.class; // correct
Class.forName(): If the fully-qualified name of a class is available, it is possible to get the corresponding Class using the static method Class.forName() Class cString = Class.forName("java.lang.String;");
Inspecting a Class After we obtain a Class object myClass, we can: Get the class name
String s = myClass.getName() ; Get the class modifiers
int m = myClass.getModifiers() ;bool isPublic = Modifier.isPublic(m) ;bool isAbstract = Modifier.isAbstract(m) ;bool isFinal = Modifier.isFinal(m) ;
Test if it is an interfacebool isInterface = myClass.isInterface() ;
Get the interfaces implemented by a classClass [] itfs = myClass.getInterfaces() ;
Get the superclassClass super = myClass.getSuperClass() ;
Some ways to do introspection
79
java.lang.Class• Class.getMethods () // returns array of method objects• Class.getConstructor (Class[ ] parameterTypes)
• returns the constructor with those parameters
java.lang.reflect.Array• Array.NewInstance (Class componentType, int length)
java.lang.reflect.Field java.lang.reflect.Method All of the above require the existence of run-time
objects that describe methods and classes
Beans In Java
80
What is a Bean?
81
A Java Bean is a reusable software component that works with Java.
More specifically: a Java Bean is a reusable software component that can be visually manipulated in builder tools.
Reusable Software Components
82
Designed to apply the power and benefit of reusable, interchangeable parts from other industries to the field of software construction.
Reusable software components can be simple like familiar push buttons, text fields list boxes, scrollbars, dialogs
Beans, Widgets, Controls, and Components
83
If you come from a Windows background, you probably think in terms of visual controls, possibly Visual Basic Extensions (VBXs) or OLE Controls (OCXs) and now Active X Controls.
If you're more accustomed to environments like X Windows, you probably think in terms of toolkits or widgets.
Beans or Class Libraries
84
What is the difference between a Java Bean and an instance of a normal Java class?
Beans from typical Java classes is introspection. Tools that recognize predefined patterns in method
signatures and class definitions can "look inside" a Bean to determine its properties and behavior.
Method signatures within Beans must follow a certain pattern in order for introspection tools to recognize how Beans can be manipulated, both at design time, and run time.
Basic Bean Concepts
85
Beans share certain common defining features. • Support for introspection allowing a builder tool to analyze how a bean
works. • Support for customization allowing a user to alter the appearance and
behavior of a bean. • Support for events allowing beans to fire events, and informing builder
tools about both the events they can fire and the events they can handle. • Support for properties allowing beans to be manipulated programatically,
as well as to support the customization mentioned above. • Support for persistence allowing beans that have been customized in an
application builder to have their state saved and restored.
JavaBean Rules
86
A JavaBean must have a public, no-argument constructor (a default constructor).
The JavaBean class attributes must be accessed via accessor and mutator methods that follow a standard naming convention (getXxxx and setXxxx, isXxxx for boolean attributes. This allows frameworks to automate operations on attribute values.
The JavaBean class should be serializable. This allows Java applications and frameworks to save, store, and restore the JavaBean’s state.
Writing a Simple JavaBean
87
Simple Bean Test
88
The Java™ Platform
Umesh Bellur
High-EndServer
Java Technology Enabled Desktop
WorkgroupServer
Java Technology Enabled Devices
The JavaTM Platform
OptionalPackages
Java 2Enterprise
Edition(J2EE)
Java 2StandardEdition(J2SE)
JVM
Java Card APIs
CardVM
OptionalPackages
Personal Basis Profile
Personal Profile
Foundation Profile
CDC
MIDP
CLDC
KVM
Java 2 Platform Micro Edition(J2METM)
* Under development in JCP
J2EE 1.4 APIs and Technologies J2SE (improved) JAX-RPC (new) Web Service for J2EE J2EE Management J2EE Deployment JMX 1.1 JMS 1.1 JTA 1.0
Servlet 2.4 JSP 2.0 EJB 2.1 JAXR Connector 1.5 JACC JAXP 1.2 JavaMail 1.3 JAF 1.0
Java EE 5 and 6
JAX-WS 2.0 & JSR 181 Java Persistence EJB 3.0 JAXB 2.0 JavaSever Faces 1.2 – new to Platform JSP 2.1 – Unification w/ JSF 1.2 StAX – Pull Parser – new to Platform
‘Enterprise’ in J2EE
‘Programming in the large’ and ‘enterprise computing’ : differ from small-scale and academic computing
• Lots of users and the application has an ‘extended life’• Deployed on heterogeneous computing environments• Needs to have versioning mechanism• Developed by a team of developers over long time• Maintainability, Flexibility, Reusability are major issues
Difficulties• Needs to support transactions, resource-pooling, security, threading,
persistence, life-cycle management etc…• System programming at the expense of business logic• Developers have to become specialists• Proprietary APIs result in non-portable code
Need for special solutions to manage complexity • Proprietary frameworks and middleware• Need for standard APIs for enterprise computing• Multi-tiered architecture in enterprise applications
J2EE Platform Architecture Component
• A component is an application level software unit.• The J2EE platform supports the following types of components :
• Applets, • Application clients, • Web components and• Enterprise Java Beans (EJBs)
Container• All J2EE components depend on the runtime support of a system-level entity
called a container. • Containers provide components with services such as
• life cycle management, • security, • deployment • threading