Advanced Programming

Advanced Programming Rabie A. Ramadan Rabie@rabieramadan.org http://www.rabieramadan.org/classes/2012/Advpro/ Lecture 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 Agenda

Asingle threaded program class ABC { …. public void main(..) { … .. } } begin body end

A Multithreaded Program Main Thread start start start Thread A Thread B Thread C Threads may switch or exchange data/results

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

Multithreaded Server: For Serving Multiple Clients Concurrently Server Process Client 1 Process Server Threads • Internet Client 2 Process

Web/Internet Applications:Serving Many Users Simultaneously PC client Internet Server Local Area Network PDA

Modern Applications need Threads (ex1): Editing and Printing documents in background. Multithreaded Applications Printing Thread Editing Thread

Multithreaded/Parallel File Copy • reader() • { • - - - - - - - - - - • lock(buff[i]); • read(src,buff[i]); • unlock(buff[i]); • - - - - - - - - - - • } • writer() • { • - - - - - - - - - - • lock(buff[i]); • write(src,buff[i]); • unlock(buff[i]); • - - - - - - - - - - • } buff[0] buff[1] Cooperative Parallel Synchronized Threads 9

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. What are Threads?

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. Java Threads

Threading Mechanisms... • Create a class that extends the Thread class • Create a class that implements the Runnable interface Thread Runnable Thread MyThread MyClass (objects are threads) (objects with run() body) [a] [b]

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

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(); } } An example

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 • Write class that extends Thread, e.g. MyThread • Define your own run() • Create a MyThread object and call start() on it • We won’t do this! Not good design

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: MyThreadmyObject = new MyThread(); Creating Thread Object: Thread thr1 = new Thread( myObject ); Start Execution: thr1.start(); 2nd method: Threads by implementing Runnable interface

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(); } } An example

new start() I/O completed ready resume() Time expired/interrupted notify() sleeping blocked waiting dispatch sleep() wait() suspend() running Block on I/O completion stop() dead Life Cycle of Thread

Write a program that creates 3 threads A Program with Three Java Threads

Three threads example • class A extends Thread • { • public void run() • { • for(inti=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"); • } • }

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(); • } • }

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 Run 1

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 Run2

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

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

Online Bank: Serving Many Customers and Operations PC client Internet Bank Server Local Area Network Bank Database PDA

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() { … } Shared Resources

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

Shared account object between 3 threads class MyThread implements Runnable { Accountaccount; 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 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. } }

The master/worker model The peer model A thread pipeline Thread concurrency/operation models

Themaster/worker model Program Resources Workers Files taskX Databases Master taskY main ( ) Input (Stream) Disks taskZ Special Devices

Resources Files Databases Disks taskZ Special Devices Thepeermodel Program Workers Input taskX taskY

Files Files Files Databases Databases Databases Disks Disks Disks Special Devices Special Devices Special Devices A thread pipeline Program Filter Threads Stage 1 Stage 2 Stage 3 Input (Stream) Resources

Java Serialization

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 So you want to save your data…

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 MyClassloadYourself(Reader r) throws IOException { … } }

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

Saving/Loading Recursive Data Structs public interfaceSaveable{ // 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 • 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 • 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”

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. Approach 3: Enter Serialization...

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 emptySerializableinterface. • An empty interface is called a markerinterface.

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 basics

Serialization code FileOutputStream out = new FileOutputStream( “save.ser” ); ObjectOutputStreamoos = 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 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 Things that you don’t want to save public class MyClass implements Serializable { private int _primaryVal=3; // is serialized private transientint _cachedVal=_primaryVal*2; // _cachedVal is not serialized }

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

Graphs Vector 1010100101 OutputStream Object i Object n …

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: #1 -- Efficiency

Advanced Programming