Benefits of Concurrency in Java & Android: Program Structure

Size: px

Start display at page:

Download "Benefits of Concurrency in Java & Android: Program Structure"

Eleanore Underwood
5 years ago
Views:

1 Benefits of Concurrency in Java & Android: Program Structure Douglas C. Schmidt Institute for Software Integrated Systems Vanderbilt University Nashville, Tennessee, USA

2 Learning Objectives in this Part of the Module Recognize how concurrency can improve performance in Java & Android Recognize how concurrency can improve responsiveness in Java & Android Recognize how concurrency can improve program structure in Java & Android 2

3 Overview of Event-Driven Programs 3

4 Overview of Event-Driven Programs Many software programs have historically been structured via a purely eventdriven programming model See en.wikipedia.org/wiki/ 4 Event-driven_programming

5 Overview of Event-Driven Programs Many software programs have historically been structured via a purely eventdriven programming model The program flow is guided by events See developer.android.com/guide/ 5 components/activities/activity-lifecycle.html

by events e.g., user interface actions, sensor I/O, messages from elsewhere, etc.

setonclicklistener(new OnClickListener() { @Override public void onclick(view v)

6 Overview of Event-Driven Programs Many software programs have historically been structured via a purely eventdriven programming model The program flow is guided by events e.g., user interface actions, sensor I/O, messages from elsewhere, etc. Button button = (Button) findviewbyid(r.id.loadbutton); button.setonclicklistener(new OnClickListener() public void onclick(view v) { }}); A GUI component sending an event to its registered listener GUI Component (e.g., a button) 6

perform actions in response to user input Queue e.g.

7 Overview of Event-Driven Programs Many software programs have historically been structured via a purely eventdriven programming model The program flow is guided by events Event-driven programming is a common model in GUIs that perform actions in response to user input Queue e.g., a single event loop in the Android UI thread processes all the user-facing events Event Loop UI Thread (main thread) See developer.android.com/training/ 7 multiple-threads/communicate-ui.html

8 Limitations with Purely Event-Driven Programs 8

9 Limitations with Purely Event-Driven Programs For certain types of apps purely event-driven software is hard to understand & is inefficient Queue Event Loop UI Thread (main thread) 9

10 Limitations with Purely Event-Driven Programs For certain types of apps purely event-driven software is hard to understand & is inefficient e.g., an app that downloads/displays images from web servers Queue Event Loop UI Thread (main thread) 10

, an app that downloads/displays images from web servers Queue To avoid starvation of other tasks,

11 Limitations with Purely Event-Driven Programs For certain types of apps purely event-driven software is hard to understand & is inefficient e.g., an app that downloads/displays images from web servers Queue To avoid starvation of other tasks, long-duration blocking operations are disallowed in the UI thread Event Loop UI Thread (main thread) Moreover, there s just a single 11 thread, i.e., the UI thread!

12 Limitations with Purely Event-Driven Programs For certain types of apps purely event-driven software is hard to understand & is inefficient e.g., an app that downloads/displays images from web servers Queue Event Loop Long-duration operations are run asynchronously by posting messages in the message queue of the UI thread s event loop UI Thread (main thread) 12

13 Limitations with Purely Event-Driven Programs For certain types of apps purely event-driven software is hard to understand & is inefficient e.g., an app that downloads/displays images from web servers Queue Event Loop e.g., a message requesting an asynchronous read of a socket could be posted to the UI thread s event loop UI Thread (main thread) 13

hard to understand & is inefficient e.g.

Queue Asynchronous operation completion is handled later

14 Limitations with Purely Event-Driven Programs For certain types of apps purely event-driven software is hard to understand & is inefficient e.g., an app that downloads/displays images from web servers Queue Asynchronous operation completion is handled later via messages in the UI thread s event loop Event Loop UI Thread (main thread) 14

15 Limitations with Purely Event-Driven Programs For certain types of apps purely event-driven software is hard to understand & is inefficient e.g., an app that downloads/displays images from web servers Queue Event Loop e.g., the completion of the async read indicates how many bytes were read in from the socket UI Thread (main thread) 15

16 Limitations with Purely Event-Driven Programs For certain types of apps purely event-driven software is hard to understand & is inefficient e.g., an app that downloads/displays images from web servers These steps may be repeated multiple times until the image is completely downloaded Event Loop Queue UI Thread (main thread) See en.wikipedia.org/wiki/lather,_rinse,_repeat 16

17 Limitations with Purely Event-Driven Programs For certain types of apps purely event-driven software is hard to understand & is inefficient e.g., an app that downloads/displays images from web servers These steps may be repeated multiple times until the image is completely downloaded Event Loop Queue UI Thread (main thread) Note the disconnect in both time & space between 17 operation invocation & operation completion

18 Limitations with Purely Event-Driven Programs Poorly structured event-driven software often leads to spaghetti code or a big ball of mud See en.wikipedia.org/wiki/spaghetti_code 18 & en.wikipedia.org/wiki/big_ball_of_mud

19 Limitations with Purely Event-Driven Programs Poorly structured event-driven software often leads to spaghetti code or a big ball of mud This type of code is hard to understand since there s little/no structure or linear flow of control to guide developers 19

20 Limitations with Purely Event-Driven Programs Poorly structured event-driven software often leads to spaghetti code or a big ball of mud This type of code is hard to understand since there s little/no structure or linear flow of control to guide developers Single-threaded programs that are driven purely by events can obscure the flow of control in time & space Step 2 Step 5 Step 3 Step 4 Step 6 Step 1 20

Limitations with Purely Event-Driven Programs Poorly structured event-driven software often leads to spaghetti code or a big ball of mud This type of code is hard to understand since there s

21 Limitations with Purely Event-Driven Programs Poorly structured event-driven software often leads to spaghetti code or a big ball of mud This type of code is hard to understand since there s little/no structure or linear flow of control to guide developers Single-threaded programs that are driven purely by events can obscure the flow of control in time & space Step 2 Step 5 Step 3 Step 4 Step 6 Step 1 It s hard to understand software when its 21 flow of control bounces all over the place

22 Limitations with Purely Event-Driven Programs Poorly structured event-driven software often leads to spaghetti code or a big ball of mud This type of code is hard to understand since there s little/no structure or linear flow of control to guide developers Single-threaded programs that are driven purely by events can obscure the flow of control in time & space It s also hard to sustain since small changes can break nearly anything due to non-intuitive dependencies 22

23 Simplifying Program Structure with Concurrency 23

24 Simplifying Program Structure with Concurrency Concurrency mechanisms & frameworks can help overcome drawbacks with purely event-driven programs 24

25 Simplifying Program Structure with Concurrency Concurrency mechanisms & frameworks can help overcome drawbacks with purely event-driven programs Multi-threading enables more intuitive (& often performant) ways to structure software See en.wikipedia.org/wiki/ 25 Multithreading_(computer_architecture)

26 Simplifying Program Structure with Concurrency Concurrency mechanisms & frameworks can help overcome drawbacks with purely event-driven programs Multi-threading enables more intuitive (& often performant) ways to structure software e.g., operations that run for long-durations can block synchronously 26

Simplifying Program Structure with Concurrency Concurrency mechanisms & frameworks can help overcome drawbacks with purely event-driven programs Multi-threading enables more intuitive (& often

27 Simplifying Program Structure with Concurrency Concurrency mechanisms & frameworks can help overcome drawbacks with purely event-driven programs Multi-threading enables more intuitive (& often performant) ways to structure software e.g., operations that run for long-durations can block synchronously Synchronous blocking within a thread can often 27 yield a more natural & collaborative control flow

28 Simplifying Program Structure with Concurrency Android s HaMeR concurrency framework can help simplify program structure Queue Background Thread A Handler Looper Handler Runnable Background Thread B UI Thread (main thread) See next part of this lesson for 28 an Android example for this code

that run for long-durations can block in threads Queue Handler

29 Simplifying Program Structure with Concurrency Android s HaMeR concurrency framework can help simplify program structure Operations that run for long-durations can block in threads Queue Handler Background Thread A Looper Handler Runnable Background Thread B UI Thread (main thread) 29

simplify program structure Queue Background

Short-duration operations run in the UI thread

30 Simplifying Program Structure with Concurrency Android s HaMeR concurrency framework can help simplify program structure Queue Background Thread A Handler Looper Handler Runnable Short-duration operations run in the UI thread & don t block Background Thread B UI Thread (main thread) 30

s HaMeR concurrency Short-duration framework supports a hybrid operations run

31 Simplifying Program Structure with Concurrency Android s HaMeR concurrency framework can help simplify program structure Queue Background Thread A Android s HaMeR concurrency Short-duration framework supports a hybrid operations run in programming model, i.e., part the UI thread & concurrent (half-sync) & part don t block event-driven (half-async) Looper Handler Handler Runnable Background Thread B UI Thread (main thread) See 31

Simplifying Program Structure with Concurrency Android s HaMeR concurrency framework can help simplify program structure Queue Background Thread A Handler Looper Handler

32 Simplifying Program Structure with Concurrency Android s HaMeR concurrency framework can help simplify program structure Queue Background Thread A Handler Looper Handler Runnable Background Thread B UI Thread (main thread) No more spaghetti code or big ball of mud since the app is neatly 32 organized in a more linear structure that doesn t bounce around!

Background Thread B UI Thread (main thread)

33 Simplifying Program Structure with Concurrency Android s HaMeR concurrency framework can help simplify program structure This framework implements various POSA concurrency patterns e.g., Command Processor, Active Object, Half-Sync/Half-Async Queue Handler Background Thread A Looper Handler Runnable Background Thread B UI Thread (main thread) See 33 & en.wikipedia.org/wiki/concurrency_pattern

34 End of Benefits of Concurrency in Java & Android (Part 3) 34

35 Discussion Questions 1. Which of the following are problems with poorly structured event-driven programs? a. It s performance & responsiveness are poor since there is little/no structure or linear flow of control to guide developers b. It s hard to understand since there s little/no structure or linear flow of control to guide developers c. It s hard to sustain since small changes can break nearly anything due to non-intuitive dependencies d. Synchronous blocking in threads can often yield a less natural & collaborative control flow 35

36 Discussion Questions 2. How does concurrency help to simplify program structure? a. It provides a disconnect in both time & space between operation invocation & operation completion b. Concurrent programs can obscure the flow of control in both time & space c. Synchronous blocking within a thread can often yield a more natural & collaborative control flow d. Synchronous blocking within a thread can often yield a less natural & collaborative control flow 36

37 Benefits of Concurrency in Android: App Case Study Douglas C. Schmidt Institute for Software Integrated Systems Vanderbilt University Nashville, Tennessee, USA

structure in Java & Android Know how concurrency benefits can be applied to avoid overly complex & tangled event-driven

38 Learning Objectives in this Part of the Module Recognize how concurrency can improve performance in Java & Android Recognize how concurrency can improve responsiveness in Java & Android Recognize how concurrency can improve program structure in Java & Android Know how concurrency benefits can be applied to avoid overly complex & tangled event-driven solutions in Java & Android e.g., an app that concurrently downloads an image 2 from a remote web server & displays it to the user

39 Analyzing the Image Download App 3

40 Analyzing the Image Download App This app downloads images from remote web servers & displays them Socket Socket See github.com/douglascraigschmidt/posa/ 4 tree/master/ex/m3/imagedownloader/sync

with a runnable implementation to download images Socket

41 Analyzing the Image Download App This app downloads images from remote web servers & displays them Uses a Java thread with a runnable implementation to download images Socket Socket Allows image downloading to take 5 advantage of multi-core processors

42 Analyzing the Image Download App This app downloads images from remote web servers & displays them Uses a Java thread with a runnable implementation to download images The following lambda expression specifies what work the thread should run new Thread(() -> { /* Code to run goes here */ }).start(); The Java 8 version using lambda expressions is 6 very concise since it omits all unnecessary syntax!

43 Analyzing the Image Download App This app downloads images from remote web servers & displays them Uses a Java thread with a runnable implementation to download images The following lambda expression specifies what work the thread should run new Thread(() -> { /* Code to run goes here */ }).start(); The Java Thread class creates & controls the unit of execution that processes the lambda expression See docs.oracle.com/javase/tutorial/ 7 essential/concurrency/runthread.html

44 Analyzing the Image Download App This app downloads images from remote web servers & displays them Uses a Java thread with a runnable implementation to download images See upcoming lesson on 8 Overview of Java Threads

45 Analyzing the Image Download App This app downloads images from remote web servers & displays them Uses a Java thread with a runnable implementation to download images Uses Android HaMeR concurrency framework to pass results to UI thread Socket Socket See code.tutsplus.com/tutorials/concurrency-onandroid-using-hamer-framework--cms

46 Analyzing the Image Download App This app downloads images from remote web servers & displays them Uses a Java thread with a runnable implementation to download images Uses Android HaMeR concurrency framework to pass results to UI thread Socket Socket Downloading of images is 10 done in background threads

47 Analyzing the Image Download App This app downloads images from remote web servers & displays them Uses a Java thread with a runnable implementation to download images Uses Android HaMeR concurrency framework to pass results to UI thread Socket Socket Displaying of images is 11 done in the UI thread

framework to pass results to UI thread This solution intentionally doesn t handle interrupts or

48 Analyzing the Image Download App This app downloads images from remote web servers & displays them Uses a Java thread with a runnable implementation to download images Uses Android HaMeR concurrency framework to pass results to UI thread This solution intentionally doesn t handle interrupts or runtime configuration changes Socket Socket See upcoming lesson on Managing 12 the Java Thread Lifecycle

49 Analyzing the Image Download App As a reminder, the purely event-driven solution was not cohesive Note disconnect between operation invocation & operation completion in both time & space Event Loop Queue UI Thread (main thread) See the previous part 13 of this lesson for details

50 Analyzing the Image Download App The structure of this concurrent app is more cohesive in time & space Called when user presses download button public void downloadimage(view view) { Uri url = geturl(); showdialog("downloading via HaMeR"); startdownload(url); 14

51 Analyzing the Image Download App The structure of this concurrent app is more cohesive in time & space public void downloadimage(view view) { Uri url = geturl(); showdialog("downloading via HaMeR"); startdownload(url); Get the URL entered by user 15

52 Analyzing the Image Download App The structure of this concurrent app is more cohesive in time & space public void downloadimage(view view) { Uri url = geturl(); showdialog("downloading via HaMeR"); startdownload(url); Display dialog to user while download is in progress 16

53 Analyzing the Image Download App The structure of this concurrent app is more cohesive in time & space public void downloadimage(view view) { Uri url = geturl(); showdialog("downloading via HaMeR"); startdownload(url); Initiate downloading of the image at the url 17

54 Analyzing the Image Download App The structure of this concurrent app is more cohesive in time & space Performs the image download public void startdownload(uri url) { new Thread(() -> { Uri pathname = downloadimage(this, url); runonuithread(() -> displayimage(pathname)); }).start(); 18

55 Analyzing the Image Download App The structure of this concurrent app is more cohesive in time & space public void startdownload(uri url) { new Thread(() -> { Uri pathname = downloadimage(this, url); Define a lambda expression runonuithread(() -> displayimage(pathname)); }).start(); 19

56 Analyzing the Image Download App The structure of this concurrent app is more cohesive in time & space public void startdownload(uri url) { new Thread(() -> { Uri pathname = downloadimage(this, url); runonuithread(() -> displayimage(pathname)); }).start(); Start a new thread Runtime thread stack See developer.android.com/guide/components/ 20 processes-and-threads.html#workerthreads

57 Analyzing the Image Download App The structure of this concurrent app is more cohesive in time & space public void startdownload(uri url) { new Thread(() -> { Uri pathname = downloadimage(this, url); Blocks downloading image in background thread runonuithread(() -> displayimage(pathname)); }).start(); 21

58 Analyzing the Image Download App The structure of this concurrent app is more cohesive in time & space public void startdownload(uri url) { new Thread(() -> { Uri pathname = downloadimage(this, url); Create command to run in UI thread (non-blocking) runonuithread(() -> displayimage(pathname)); }).start(); See 22 ~schmidt/commandprocessor.pdf

59 Analyzing the Image Download App The structure of this concurrent app is more cohesive in time & space public void startdownload(uri url) { new Thread(() -> { Uri pathname = downloadimage(this, url); runonuithread(() -> displayimage(pathname)); }).start(); Display image in UI thread (non-blocking) 23

60 Analyzing the Image Download App The structure of this concurrent app is more cohesive in time & space public void startdownload(uri url) { new Thread(() -> { Uri pathname = downloadimage(this, url); These methods run in different threads runonuithread(() -> displayimage(pathname)); }).start(); 24

61 Analyzing the Image Download App The structure of this concurrent app is more cohesive in time & space public void startdownload(uri url) { new Thread(() -> { Uri pathname = downloadimage(this, url); runonuithread(() -> displayimage(pathname)); }).start(); The Android HaMeR-based version of this code is easier to understand than the 25 purely event-driven version since it doesn t bounce around in time & space!

62 End of Benefits of Concurrency in Java & Android (Part 4) 26

63 Discussion Questions 1. Which of the following are reasons why the concurrent version of the app is better structured than the purely event-driven version? a. It can take advantage of Java 8 programming language features, such as lambda expressions b. It can take advantage of multi-core processors to run downloads in parallel c. It is more cohesive in time & space since the code that downloads an image can block synchronously d. It is more cohesive in time & space since the code that downloads an image must run asynchronously without blocking 27

Overview of Java Threads (Part 2)

Overview of Java Threads (Part 2) Douglas C. Schmidt d.schmidt@vanderbilt.edu www.dre.vanderbilt.edu/~schmidt Institute for Software Integrated Systems Vanderbilt University Nashville, Tennessee, USA Learning