Lec 10 agenda >git fetch origin lab10g; > git checkout -b lab10g origin/lab10g; Format/rules for Week 11 Advanced Topics (all beyond the scope of this course) – Serialization Sockets – Concurrency (Threads) Lab

Serialization Allows you to turn Java Objects into serial data that can be either saved to a file, stored in a db, or sent over a network. Useful for persisting data.

Serialization analogy to physics Objects in Memory space are in a gas state and they're alive. Serialized objects are liquid and they're suspended (they can flow across networks, and be persisted to a hard- drives and databases)

Serialization Syntax FileOutputStream filOut = new FileOutputStream("gamestate.ser"); ObjectOutputStream out = new ObjectOutputStream(filOut); out.writeObject(gst); out.close(); filOut.close();

Deserialization Syntax FileInputStream filIn = new FileInputStream("gamestate.ser"); ObjectInputStream ois = new ObjectInputStream(filIn); gst= (GameState) ois.readObject(); ois.close(); filIn.close();

Sockets See example package called socket from lab10

Concurrency (Threads) Threads allow you to do tasks in parallel. In an unthreaded program, you code is executed serially, from start to finish. In a threaded program, you can have multiple threads working concurrently.

Process vs. Threads Process: A process runs independently and isolated of other processes. It cannot directly access shared data in other processes. The resources of the process are allocated to it via the operating system, e.g. memory and CPU time. Threads: threads are so-called lightweight processes which have their own call-stack but can access shared data on the heap. Every thread has its own memory cache. If a thread reads shared data it stores this data in its own memory cache.

Threads are short-lived Threads are like processes, only they're short-lived. How short-lived? – When run() method terminates or returns – The thread is interrupted – An exception is thrown inside run()

Concurrency (Threads) Concurrency is achieved through time- slicing. This is where the processor cycles through each active thread for an indeterminate period of time (the slice). This gives the illusion that there are multiple processes. With multi-core processors, this may mean, true multi-threading is possible, but NOT guaranteed Invoke jvisualvm

Amdahl's Law Concurrency promises to perform certain task faster as these tasks can be divided into subtasks and these subtasks can be executed in parallel. Of course the runtime is limited by parts of the task which can be performed in parallel. The theoretical possible performance gain can be calculated by Amdahl's Law. If F (fixed) is the percentage of the program which can not run in parallel and n is the number of processes then the maximum performance gain is: 1/ (F+ ((1-F)/n)).

Concurrency Issues Liveliness: The program reacts slowly due to concurrent access of data. Safety: The program creates incorrect data.

Concurrency Imperatives Liveliness: The program must react quickly despite concurrent access of data. Safety: The program must produce correct data. These two imperatives are at odds and there is a trade-off between them. The best multi-threaded programs balance these two imperatives.

Syncrhonized keyword that only a single thread can execute a block of code at the same time ensures that each thread entering a synchronized block of code sees the effects of all previous modifications that were guarded by the same lock

Volatile keyword If a variable is declared as volatile then it is guaranteed that any thread which reads the field will see the most recently written value. This is to guard against caching. If you use synchronized properly, you don't need to worry about volatile at all.

Car + Engine + Turn-key Thread Runnable.start()

Car + Engine + Turn-key Thread Runnable.start() Thread thr = new Thread(new MyRunner()); thr.start(); //start will spawn a new thread

private class MyRunner implements Runnable public void run() { //do some work } Thread thr = new Thread(new MyRunner()); thr.start(); Define your own Runnable class

Thread thr = new Thread(new Runnable() public void run() { } }); thr.start(); anonymous-inner class

new Thread(new Runnable() public void run() { } }).start(); Reference anonymous thread and anonymous-inner class

private class MyRunningThread extends Thread public void run { //do some work } new MyRunningThread().start(); Thread which can run itself

Thread Pools Thread Pools manage (and limit) the number of active threads. This tends to be more orderly and more efficient for scaled applications.

Synchronizing methods When multiple threads have access to the same object, it makes sense to synchronize those methods which are prone to concurrency errors. The bank account example.

Thread-safe collections // pi/java/util/concurrent/package- summary.html

Big Java by Cay Horstmann Copyright © 2009 by John Wiley & Sons. All rights reserved. Running a Thread Implement a class that implements the Runnable interface: public interface Runnable { void run(); } Place the code for your task into the run method of your class: public class MyRunnable implements Runnable { public void run() { Task statements... } }

Big Java by Cay Horstmann Copyright © 2009 by John Wiley & Sons. All rights reserved. Running a Thread Create an object of your subclass: Runnable r = new MyRunnable(); Construct a Thread object from the runnable object: Thread t = new Thread(r); Call the start method to start the thread: t.start();

Big Java by Cay Horstmann Copyright © 2009 by John Wiley & Sons. All rights reserved. Running Threads sleep puts current thread to sleep for given number of milliseconds: Thread.sleep(milliseconds) When a thread is interrupted, most common response is to terminate run

Big Java by Cay Horstmann Copyright © 2009 by John Wiley & Sons. All rights reserved. Generic run method public void run() { try { Task statements } catch (InterruptedException exception) { } Clean up, if necessary }

Big Java by Cay Horstmann Copyright © 2009 by John Wiley & Sons. All rights reserved. ch20/greeting/GreetingRunnable.java 1 import java.util.Date; 2 3 /** 4 A runnable that repeatedly prints a greeting. 5 */ 6 public class GreetingRunner implements Runnable 7 { 8 private static final int REPETITIONS = 10; 9 private static final int DELAY = 1000; private String strGreeting; /** 14 Constructs the runnable object. aGreeting the greeting to display 16 */ 17 public GreetingRunner(String strGreeting) 18 { 19 this.strGreeting = strGreeting; 20 } 21 Continued

Big Java by Cay Horstmann Copyright © 2009 by John Wiley & Sons. All rights reserved. To Start the Thread Construct an object of your runnable class: Runnable t = new GreetingRunnable("Hello World"); Then construct a thread and call the start method: Thread t = new Thread(r); t.start();

Big Java by Cay Horstmann Copyright © 2009 by John Wiley & Sons. All rights reserved. Thread Scheduler Thread scheduler: runs each thread for a short amount of time (a time slice) Then the scheduler activates another thread There will always be slight variations in running times - especially when calling operating system services (e.g. input and output) There is no guarantee about the order in which threads are executed

Big Java by Cay Horstmann Copyright © 2009 by John Wiley & Sons. All rights reserved. Terminating Threads A thread terminates when its run method terminates Do not terminate a thread using the deprecated stop method Instead, notify a thread that it should terminate: t.interrupt(); interrupt does not cause the thread to terminate – it sets a boolean variable in the thread data structure

Big Java by Cay Horstmann Copyright © 2009 by John Wiley & Sons. All rights reserved. Terminating Threads The run method should check occasionally whether it has been interrupted Use the interrupted method An interrupted thread should release resources, clean up, and exit: public void run() { for (int i = 1; i <= REPETITIONS && !Thread.interrupted() ; i++) { Do work } Clean up }

Big Java by Cay Horstmann Copyright © 2009 by John Wiley & Sons. All rights reserved. Terminating Threads Java does not force a thread to terminate when it is interrupted It is entirely up to the thread what it does when it is interrupted Interrupting is a general mechanism for getting the thread’s attention

Big Java by Cay Horstmann Copyright © 2009 by John Wiley & Sons. All rights reserved. Synchronizing Object Access When a thread calls lock, it owns the lock until it calls unlock A thread that calls lock while another thread owns the lock is temporarily deactivated Thread scheduler periodically reactivates thread so it can try to acquire the lock Eventually, waiting thread can acquire the lock

SwingWorker SwingWorker takes two Object parameters. +The first is the return value and is passed to done() +The second parameter is the progress value and is passed to publish/process. Example: SwingWorker There are three important methods of SwingWorker. +doInBackGround() --background thread +process() -main UI thread +done() -main UI thread