1. SE-2811
11/11/2018
If you think the internet is not working in its current incarnation, you can’t change the system through think-pieces and F.C.C. regulations alone. You need new code [... you need cryptocurrency!].
Stephen Johnson, "Beyond the Bitcoin Bubble,” New York Times, Jan 15th 2018
[Interpretation added]
18q2-7-1
SE-2811
Dr. Mark L. Hornick
Dr. Yoder

2. 9. Threads SE2811 Software Component Design
Dr. Rob Hasker (based on slides by Dr. Mark Hornick)
9. Threads

3. What SE1011 students are told…
When the main() method is called, the instructions within the method begin to execute in sequence
The program terminates when the main() method finishes executing
But is this really true?
TBD: Rewrite examples using JavaFX

4. The ugly truth…
A running program is a collection of “threads” – essentially independent execution streams
When the main() method is called, the instructions within the method begin to execute in sequence on a primary thread
The program terminates when the primary thread, and any additional threads, finish executing

5. What’s a Thread? Defining Process:
A process is most easily understood as a program or application running on your PC
A process generally has a complete, private set of basic run- time resources, in particular:

6. By default, a Process creates and executes a single, primary Thread
BUT: A process can create and execute more than one thread
The JVM works with the OS to create processes and threads
The underlying OS provides the essential multiprocessing support

7. Modern systems: multiple processes run simultaneously
(On single-CPU PC’s) each process runs individually for a discrete time period
while one process runs, other processes sleep
The process currently executing changes very rapidly - every few milliseconds
Operating systems use a scheduler to distribute CPU time among processes
The net effect is that you (the user) observe all processes running simultaneously and continuously

8. Java application: the JVM creates a Process and a Primary Thread
The primary thread begins executing the main() method in the main class
If no other threads are created, the process terminates when the primary thread terminates
That is, when there are no more instructions to execute on that thread
Note: other Java programs, like applets, begin execution with an init() method

9. Single-threaded application
public class App { public static void main(String[] args) { App me = new App(); me.method_A(); } private void method_A() { // more code here method_B(); return; private void method_B() { private void method_C() {
Threads wind their way through the code until they run out of instructions to execute

10. Where do other threads come from?
Additional threads are created by a Java-FX application
Java applications that create and display windows cause JavaFX to create additional threads
Additional threads are created by various Java utility classes
Eg: the Timer class
Threads can be created explicitly
with the Thread class

11. Creating a multi-threaded application using JavaFX
Call launch from main(), launch calls start()
But Start runs on the “JavaFX application thread”
All work on GUI objects must be performed on this thread.
Within start(), we create an Application window containing Buttons, TextFields, etc
on the “JavaFX application thread”
Connect the Buttons, etc. to an EventHandlers
architecture.htm

12. Using a Timer is fairly straighforward:
Timeline refreshTimer =
new Timeline(new KeyFrame(Duration.millis(10000),
(ActionEvent e) -> { getBusData(); });
refreshTimer.setCycleCount(Animation.INDEFINITE);
refreshTimer.play();
The lambda expression argument to the constructor is an object that implements the EventHandler interfae
That is, the object contains an handle() method.
Which then call getBusData() in this example.
Whenever the Timer generates a timeout event, the JVM invokes handle() method on the JavaFX application thread

13. Explicitly creating additional threads
Thread t = new Thread(r);
t.start();
The r argument to the Thread constructor is a reference to a class that implements the Runnable interface
Runnable declares a single method: public void run()
When the Thread’s start() method is called, the instructions in the run() method begin executing on the new thread.
start() returns essentially immediately; it does not wait for the started thread to finish execution

14. The main class may implement the Runnable interface itself:
public class App implements Runnable { public static void main(String[] args) { App me = new App(); me.method_A(); } private void method_A() { // more code here method_B(); return;
private void method_B() {
Thread t = new Thread(this); // App is runnable!
t.start(); // start executing the run() method
return; }
public void run() {
// more code here

15. Both threads execute simultaneously and independently after the secondary thread is started
public class App implements Runnable{ public static void main(String[] args) { App me = new App() me.method_A(); } private void method_A() { // more code here method_B(); return private void method_B() { Thread t = new Thread(this); t.start();// execute run() on new thread return; public void run() {

16. The secondary thread may execute a method defined in another class that implements Runnable
public class App { public static void main(String[] args) { App me = new App(); me.method_A(); } private void method_A() { ThreadRunner tr = new ThreadRunner(); Thread t = new Thread(tr); t.start(); return; private class ThreadRunner implements Runnable { // inner class public void run() { // more code here

17. The secondary thread may execute a lambda expression
public class App { public static void main(String[] args) { App me = new App(); me.method_A(); } private void method_A() { // assume declared x, y, z here... Thread t = new Thread(()-> method_to_run(x, y, z)); t.start(); return; private void method_to_run(int a, int b, String q) { System.out.print(a + b); System.out.print(q);
This method gets executed in place of the run (when t.start() is executed)

18. An application may be designed to execute the same instructions on more than one thread at the same time
public class App implements Runnable { public static void main(String[] args) { App me = new App(); me.method_A(); } private void method_A() { ThreadRunner tr = new ThreadRunner(); Thread t = new Thread(tr); t.start(); // execute run() on new secondary thread method_C(); // execute method_C on the primary thread private void method_C() { // more code here public void run() { // some other instruction is here method_C(); // execute method_C on the secondary thread

19. Question:
Is it a good idea to let two (or more) threads execute the same code at the same time?
See

20. S Keeping code thread-safe
Fortunately, Java supports several mechanisms for synchronizing the execution of multiple threads S

21. If a method is declared to be synchronized, it will only be run on a single thread at a time
public class App implements Runnable { public static void main(String[] args) { App me = new App() me.method_A(); } private void method_A() { ThreadRunner tr = new ThreadRunner(); Thread t = new Thread(tr); t.start(); method_C(); // run method_C on the primary thread private synchronized void method_C() { // More code here public void run() { // some other instructions here method_C(); // run method_C on the secondary thread

22. private synchronized void method_C() {
Once a thread enters a synchronized method, no other threads can enter until the first thread completes execution of the method, and exits the method.
Thread y
Thread z
Thread x
If all threads get to the method at the same time, the thread that gets to enter the method first is determined arbitrarily by the Scheduler.
private synchronized void method_C() {
<statement 1>
<statement 2>
<statement 3> }
When Thread x leaves the method, the Scheduler arbitrarily allows one of the other threads to enter the method. When the second thread exits, the Scheduler allows another waiting thread to enter.

23. private synchronized void method_C() {
Once a thread enters a synchronized method, no other threads can enter until the first thread completes execution of the method, and exits the method.
Thread y
Thread z
Thread x
If all threads get to the method at the same time, the thread that gets to enter the method first is determined arbitrarily by the Scheduler.
private synchronized void method_C() {
<statement 1>
<statement 2>
<statement 3> }
When Thread x leaves the method, the Scheduler arbitrarily allows one of the other threads to enter the method. When the second thread exits, the Scheduler allows another waiting thread to enter.
Add syncronized to count_up()

24. Is synchronized the solution to everything?
Can you think of any disadvantage to making a method synchronized?

25. private void method_C() {
If only a few statements within a method need to be guarded against simultaneous execution, use a synchronized block instead of making the entire method synchronized.
Thread y
Thread z
Thread x
private void method_C() {
<safe statement 1>
<safe statement 2>
synchronized( <sync_object> ) {
<unsafe statement 3>
<unsafe statement 4>
<unsafe statement 5> }
<safe statement 6> }
When Thread x leaves the block, the Scheduler arbitrarily allows one of the other threads to enter.

26. The synchronizing object can be any object
Java’s Object class incorporates the concept of something called a monitor
Monitors are used to guard the gates of synchronized blocks
Monitors only become active within a synchronized block

27. private void method_C() {
Since every class derives from Object, the class containing a synchronized block can act as the Monitor for the block:
Thread y
Thread z
Thread x
private void method_C() {
<safe statement 1>
<safe statement 2>
synchronized( this ) { // gate down
<unsafe statement 3>
<unsafe statement 4>
<unsafe statement 5> } // gate up
<safe statement 6> }

28. Or any generic Object can act as a Monitor
Thread y
Thread z
Thread x
private Object guard = new Object(); private void method_C() {
<safe statement 1>
<safe statement 2>
synchronized( guard ) { // gate down
<unsafe statement 3>
<unsafe statement 4>
<unsafe statement 5> } // gate up
<safe statement 6> }

29. private Object guard = new Object(); private void method_C() {
Consider the following code. Suppose all threads reach the for() loop simultaneously. How do the threads compete to run the for() loop?
Thread y
Thread z
Thread x
private Object guard = new Object(); private void method_C() {
<safe statement 1>
<safe statement 2>
for( int i=0; i<100; i++ ) {
synchronized( guard ) { // gate down
<unsafe statement 3>
<unsafe statement 4>
<unsafe statement 5> } // gate up
} // end for
<safe statement 6> }

30. private Object guard = new Object(); private void method_C() {
After each thread executes the synchronized section, it can notify the Monitor that another thread can be allowed to enter the synchronized block as soon as it relinquishes ownership of the synchronized section by entering a wait (or exiting the synchronized section)
Thread y
Thread z
Thread x
private Object guard = new Object(); private void method_C() {
<safe statement 1>
<safe statement 2>
for( int i=0; i<100; i++ ) {
synchronized( guard ) { // gate down
<unsafe statement 3>
<unsafe statement 4>
<unsafe statement 5>
guard.notify(); // signal waiting threads
guard.wait(); // wait for other threads }
} // end for
<safe statement 6> }

31. Demonstrations samples/Count2000.java
2 threads, both results are close to 1000 since no synchronization
make countUp synchronized, show works
samples/GranularCounter.java
using synchronized(object) to fix the problem – second value always 2000
samples/dblcounter.zip
build, run, observe errors (UI, math)
add synchronized(Controller), observe remove math problems
UI problems: would fix with Platform.runLater
Issue: never use the UI to store important data!

32. Review Process: running application Thread: execution stream
memory, priority, permissions, threads
Thread: execution stream
Essentially: a stream of instructions executed by CPU in a process context
Creating threads
Java Swing or JavaFx, Timer, new Thread()
A thread of a problem
What happens if two threads access the same memory at the same time
Using synchronized to avoid the problem
UI’s and threads