ADVANCED PROGRAMMING

Computer Programming is the art of making a computer do what you want it to do.

SINGLE AND MULTITHREADED PROCESSES

- threads are light-weight processes within a process
- ex:Multithreaded Server: For Serving Multiple Clients Concurrently

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 to express concurrency on both single and multiprocessors machines.

 Programming a task having multiple threads of control – Multithreading or Multithreaded Programming.

Java has built in thread support for Multithreading

 Synchronization

 Thread Scheduling

 Inter-Thread Communication

Threading Mechanisms...

 Create a class that extends the Thread class

 Create a class that implements the Runnable interface

1st method: Extending Thread class : old way (Not Good Design )

2nd method: Threads by implementing Runnable interface

Life Cycle of Thread:

- You can’ t determine sequence of running threads ,but you can change priority of threads

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

Accessing 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()

{
…
}

Thread concurrency/operation models

1 JAVA SERIALIZATION
want to save your data… , Want to store on disk and retrieve later.

In general: want your objects to be persistent

Approach 1 : use file IO

Write a set of methods for saving/loading each class that you care about

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

Pains of Approach 1
Painful when dealing with complex objects (needs recursive processing.
 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.

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.

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
FileOutputStream out = new FileOutputStream( “save.ser” );

ObjectOutputStream oos = new ObjectOutputStream( out );

oos.writeObject( new Date() );

oos.close();

Deserialization code
FileInputStream in =new FileInputStream( “save.ser” );

ObjectInputStream ois = new ObjectInputStream( in );

Date d = (Date) ois.readObject();

ois.close();

- Sometimes, you want to explicitly not store some non-static data

Java provides the “transient” keyword. Transient
private transient int _cachedVal=_primaryVal*2;

Gotchas: #1 – Efficiency
 For tables , it is not necessarily efficient, and may even be wrong bec By default, Java
will store the entire internal _table, including all of its null entries!

Gotchas: #2 -- Backward compatibility

 What happens if you serialize with a v 1.0 object and deserialize with a v1.1? Or vice
versa?
2 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

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)
o 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

How is Reflection implemented?

 Reflective capabilities need special support in language and compiler !
• Java: java.lang.reflection
• .NET: System.Reflection
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() ;

3 BEANS IN JAVA

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.

Beans are Reusable Software Components.

  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

 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.
4 THE JAVA™ PLATFORM

Java comes in many flavours to suit the required application and complexity of hardware.