Transcript Lecture 2 - Rabie A. Ramadan

Advanced Programming
Rabie A. Ramadan
[email protected]
http://www.rabieramadan.org/classes/2012/Ad
vpro/
Lecture 2
Agenda









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
2
A single threaded program
class ABC
{
….
public void main(..)
{
…
..
}
begin
body
end
}
3
A Multithreaded Program
Main Thread
start
Thread A
start
start
Thread B
Thread C
Threads may switch or exchange data/results
4
Single and Multithreaded
Processes
threads are light-weight processes within a process
Single-threaded Process
Multiplethreaded Process
Threads of
Execution
Multiple instruction stream
Single instruction stream Common
Address Space
5
Multithreaded Server: For Serving
Multiple Clients Concurrently
Server Process
Client 1 Process
Server
Threads

Internet
Client 2 Process
6
Web/Internet Applications:
Serving Many Users Simultaneously
PC client
Internet
Server
Local Area Network
PDA
7
Multithreaded Applications


Modern Applications need Threads
(ex1): Editing and Printing documents in background.
Printing Thread
Editing Thread
Multithreaded/Parallel File Copy
reader()
{
- - - - - - - - lock(buff[i]);
read(src,buff[i]);
unlock(buff[i]);
- - - - - - - - }
buff[0]
buff[1]
writer()
{
- - - - - - - - - lock(buff[i]);
write(src,buff[i]);
unlock(buff[i]);
- - - - - - - - - }
Cooperative Parallel Synchronized
Threads
9
9
What are Threads?

A piece of code that run in concurrent with other threads.

Each thread is a statically ordered sequence of instructions.

Threads are being extensively used express concurrency on
both single and multiprocessors machines.

Programming a task having multiple threads of control –
Multithreading or Multithreaded Programming.
10
Java Threads


Java has built in thread support for Multithreading
•
•
•
Synchronization
Thread Scheduling
Inter-Thread Communication:
• currentThread
• yield
• sleep
• resume
start
run
stop
setPriority
getPriority
suspend
Java Garbage Collector is a low-priority thread.
11
Threading Mechanisms...
Create a class that extends the Thread class
 Create a class that implements the Runnable
interface

Thread
MyThread
(objects are threads)
[a]
Runnable
Thread
MyClass
(objects with run() body)
[b]
12
1st method: Extending Thread
class

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();
13
An example
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();
}
}
14
Creating a Task and Thread


Warning: old way(s), new ways
First, if you have a thread object, you can call
start() on that object
• Makes it available to be run
• When it’s time to run it, Thread’s run() is called

So, create a thread using “old” (not good) way

We won’t do this! Not good design
• Write class that extends Thread, e.g. MyThread
• Define your own run()
• Create a MyThread object and call start() on it
2nd method: Threads by
implementing Runnable
interface

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();
16
An example
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();
}
}
17
Life Cycle of Thread
new
start()
I/O completed
ready
Time expired/
interrupted
notify()
sleeping
waiting
resume()
blocked
dispatch
sleep()
wait()
suspend()
running
Block on I/O
completion
stop()
dead
18
A Program with Three Java
Threads

Write a program that creates 3 threads
19
Three threads example






















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();
}
}








21
Run 1
threads [1:76] java ThreadTest
From ThreadA: i= 1
From ThreadA: i= 2
From ThreadA: i= 3
From ThreadA: i= 4
From ThreadA: i= 5
Exit from A
From ThreadC: k= 1
From ThreadC: k= 2
From ThreadC: k= 3
From ThreadC: k= 4
From ThreadC: k= 5
Exit from C
From ThreadB: j= 1
From ThreadB: j= 2
From ThreadB: j= 3
From ThreadB: j= 4
From ThreadB: j= 5
Exit from B

22
Run2
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= 5
Exit from C
From ThreadB: j= 1
From ThreadB: j= 2
From ThreadB: j= 3
From ThreadB: j= 4
From ThreadB: j= 5
Exit from B
Exit from A

23
Thread Priority

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
24
Accessing Shared Resources

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()
25
Online Bank: Serving Many
Customers and Operations
PC client
Internet Bank
Server
Local Area Network
Bank
Database
PDA
26
Shared Resources



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()
•{
•}
•…
27
the driver: 3rd Threads sharing
the same object
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()
}
28
Shared account object between
3 threads
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)
29
Monitor (shared object access):
serializes operation on shared
object
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.
}
}
30
Thread concurrency/operation
models



The master/worker model
The peer model
A thread pipeline
31
The master/worker model
Program
Resources
Workers
taskX
Files
Database
s
Master
taskY
Input (Stream)
main ( )
Disks
taskZ
Special
Devices
32
The peer model
Program
Input
Resources
Workers
taskX
Files
Database
s
taskY
Disks
taskZ
Special
Devices
33
A thread pipeline
Program
Filter Threads
Stage 1
Stage 2
Stage 3
Input (Stream)
Resources
Files
Files
Files
Database
s
Disks
Database
s
Disks
Database
s
Disks
Special
Devices
Special
Devices
Special
Devices
34
Java Serialization
35
So you want to save your data…


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
36
Answer 1


You’ve got file I/O nailed, so…
Write a set of methods for saving/loading each
class that you care about
public class MyClass {
public void saveYourself(Writer o)
throws IOException { … }
public static MyClass loadYourself(Reader r)
throws IOException { … }
}
37
Coolnesses of Approach 1




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
38
Saving/Loading Recursive Data
Structs
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
}
39
Painfulnesses of Approach 1

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.
40
Approach 2: Using Databases

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”
41
Approach 3: Enter
Serialization...

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.
42
Serialization basics

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.
43
Serialization basics

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.
44
Serialization code
FileOutputStream out =
new FileOutputStream( “save.ser” );
ObjectOutputStream oos =
new ObjectOutputStream( out );
oos.writeObject( new Date() );
oos.close();
45
Deserialization code
FileInputStream in =
new FileInputStream( “save.ser” );
ObjectInputStream ois =
new ObjectInputStream( in );
Date d = (Date) ois.readObject();
ois.close();
46
Things that you don’t want to
save


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
}
47
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
1010100101
Vector
OutputStream
Object i
…
Object n
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.0
public class MyClass {
MyClass(int arg) { _dat=arg*2; }
private int _dat;
}
// version 1.1
public 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
Java Reflection
55
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
Object
compiled
class
file
Class
Field
Method
Constructor
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 interface
bool isInterface = myClass.isInterface() ;

Get the interfaces implemented by a class
Class [] itfs = myClass.getInterfaces() ;

Get the superclass
Class super = myClass.getSuperClass() ;
Some ways to do introspection

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
63
Beans In Java
64
What is a Bean?

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.
65
Reusable Software Components


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
66
Beans, Widgets, Controls, and
Components

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.
67
Beans or Class Libraries



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.
68
Basic Bean Concepts

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.
69
JavaBean Rules



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.
70
Writing a Simple JavaBean
71
Simple Bean Test
72
The Java™ Platform
Java Technology
Enabled Devices
Java Technology
Enabled Desktop
Umesh Bellur
Workgroup
Server
High-End
Server
The JavaTM Platform
Java 2 Platform Micro Edition
(J2METM)
Optional
Packages
Optional
Packages
Java 2
Enterprise
Edition
(J2EE)
Java 2
Standard
Edition
(J2SE)
Personal
Basis Profile
Personal
Profile
Foundation Profile
CDC
JVM
MIDP
CLDC
KVM
* Under development in JCP
Java
Card
APIs
CardVM
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
Servlet &
JSP (JavaServer Pages)
What is a Servlet?



Java™ objects which extend the
functionality of a HTTP server
Dynamic contents generation
Better alternative to CGI, ISAPI, etc.
• Efficient
• Platform and server independent
• Session management
• Java-based
Servlet vs. CGI
Request
Request CGI1
CGI1
Request
RequestCGI2
CGI2
Request
Request CGI1
CGI1
Request
Request Servlet1
Servlet1
Request
Request Servlet2
Servlet2
Request Servlet1
Child
Childfor
forCGI1
CGI1
CGI
CGI
Based
Based
Webserver
Webserver
Child
Childfor
forCGI2
CGI2
Child
Childfor
forCGI1
CGI1
Servlet
Servlet Based
BasedWebserver
Webserver
JVM
JVM
Servlet1
Servlet1
Servlet2
Servlet2
What is JSP Technology?

Enables separation of business logic from
presentation
• Presentation is in the form of HTML or XML
• Business logic is implemented as Java Beans or
•


custom tags
Better maintainability, reusability
Extensible via custom tags
Builds on Servlet technology