CONCURRENT PROGRAMMING WITH THREADS R I C K M E R C E R, R I C K S N O D G R A S S, I V A N V A S Q U E Z W I T H H E L P F R O M J O S H B L O C K

Transcription

1 CONCURRENT PROGRAMMING WITH THREADS R I C K M E R C E R, R I C K S N O D G R A S S, I V A N V A S Q U E Z W I T H H E L P F R O M J O S H B L O C K

2 OUTLINE Basic concepts Processes Threads Java: Thread class Single-threaded vs. Multi-Threads Concurrent Programming Thread Safety

3 CONCURRENT PROGRAMMING Computers with no operator system (OS) can run one program at a time Only had sequential processing: executed one statement at a time, in order until done: very intuitive (Rick did this, batch processing) with Hollerith cards) An OS allows many programs to run at once Theses are known as Processes Allow better resource utilization, fairness, and convenience Threads running in a process share memory but have their own program counter, stack, and local variables Allow better resource utilization, fairness, convenience Allow one process to execute on multiple processors

4 WHY THREADS IN A PROCESS? Threads provide responsive GUIs with a separate dedicated thread fast server application throughput the ability to play an audio file in a separate Thread without freezing the GUI Allow garbage collection (runs in its own thread) Allows processes to run on different processors Allow server apps to handle multiple clients when each connection is allocated its own thread (a multi-client chat servers, our next project)

5 PROCESSES Each Process has Program counter, Registers, Page map (address space), Open files CPU context switches between processes Save registers of prior process Loads registers of current process loads new page map Processes are considered heavyweight lots of state context switch takes time

6 2 things at the same time A word processor should be able to accept input from the user and at the same time, auto-save the document Word processers have at least these two threads 1. One to handle user-input 2. Another to perform background tasks (like auto-saving) time Thread 1 user input Thread 2 background task -User types some stuff -User selects some text -User cuts -User pastes -User types more stuff - auto save timer limit reached - initiate auto-save - saving... - auto-save complete - waiting

7 2 things at the same time An integrated development environment should be abler to compile code as you type Thread 1 user input -User types some stuff -User selects some text -User cuts -User pastes -User types more stuff Thread 2 background task - Compile your code - Marks errors - waiting

8 Example (mac s activity monitor): Eclipse process had 33 threads at that moment

9 THREADS The term thread is short for thread of control A process can contain multiple threads Threads can share the same data, while processes each have their own set of data Threads are light-weight Java programs are executed in a thread the "main" thread

10 SINGLE THREADED Our Java programs have been single-threaded Only one thread running public class SingleThreadedExample_A { public static void main(string[] args) { String currentthread = Thread.currentThread().getName(); for (int i = 1; i <= 6; i++) { try { Thread.sleep(500); // 500 milliseconds == 0.5 seconds catch (InterruptedException e) { e.printstacktrace(); System.out.println(currentThread + ": " + i); main: 1 main: 2 main: 3 main: 4 main: 5 main: 6

11 ONE WAY TO START THREADS 1. Create a class that extends java.lang.thread 2. Override Thread s run method 3. Create an instance of your new class 4. Send a start message to that new instance public class SecondThread_B extends Thread { private static int counter = 0; public static void main(string[] args) { Thread thread1 = new SecondThread_B(); Thread thread2 = new SecondThread_B(); Thread thread3 = new SecondThread_B(); thread1.start(); counter++; thread2.start(); counter++; thread3.start(); counter++; System.out.println(Thread.currentThread().getName()); Output? That depends Run this public void run() { System.out.println(getName() + " counter=" + counter);

12 OR IMPLEMENT RUNNABLE AND PASS REFERNCE TO A NEW THREAD public class RunThreads_D implements Runnable { // Run this application several times to see that the // two threads are given processor time differently public static void main(string[] args) { RunThreads_D runner = new RunThreads_D(); Thread alpha = new Thread(runner); // calls overriden run Thread beta = new Thread(runner); alpha.setname("a"); beta.setname("b"); alpha.start(); public void run() { // Print the name of the current Thread 500 times for (int i = 1; i <= 500; i++) { System.out.print(Thread.currentThread().getName() + " "); if(i % 51 == 0) System.out.println(); Output? That depends Run this code

13 START A NEW THREAD TO PLAY A SONG 1. First create a class that extends java.lang.thread public class AudioFilePlayer extends Thread { 2. Override Thread s run method (here it calls public void run() { // Thread s start calls this play(); public void play() { AudioFormat decodedformat = null; try { // Play audio file bits in a loop 3. Create an instance of your new class AudioFilePlayer player = new AudioFilePlayer(audioFileName); 4. Send a start message to that new instance player.start();

14 CLIENT CODE IN SONGPLAYER public static void playfile(endofsonglistner wiater, String audiofilename) { AudioFilePlayer player = new AudioFilePlayer(audioFileName); // Because AudioFilePlayer extends Thread // Java will start a new Thread for you and then call // the run() method in the subclass player.start();

15 MULTI-THREADED OR NOT? If more than one thread is running concurrently then a program is considered multi-threaded Instead of calling Thread s start method before it calls AudioFilePlayer run() method (bypass Thread s start()) and just call our run() method directly from client // Call Thread s start() that calls our run() // player.start(); Or do not call superclass constructor // for a new Thread. Change SongPlayer.java in Jukebox player.run(); // see playfile(endofsonglistener, String) The GUI freezes! Wait until the run() method finishes (our run() method calls a play() method that loops to read the audio file and play it.

16 CONCURRENCY Concurrency is a property of systems in which several threads are executing at the same time, and potentially interacting with each other The biggest challenge in dealing with concurrent systems is in avoiding conflicts between threads When an application wants to call the same method from two different threads The one method may not have finished before the switch

17 RACE CONDITION A race condition is a type of flaw in an electronic or software system where the output is dependent on the sequence or timing of other uncontrollable events. The term originates with the idea of two signals racing each other to influence the output first, wikipedia

18 THREAD SAFETY Most Operating Systems treat threads, not processes, as the basic scheduling unit Threads execute simultaneously and asynchronously (separate from the main program flow) with respect to one another Threads share the memory address space of their owning process all threads within a process have access to the same variables and allocate objects from the same heap Without explicit synchronization to coordinate access to shared data, a thread may modify variables that another thread is in the middle of using, with unpredictable results

19 NON-COMPUTER EXAMPLE Let s meet at the coffee shop on University at 8am Whoops, on my way I realize there are two at 8:10 I wonder if you went to the other coffee shop You aren t at the other one at 8:12 What happened? 1. You didn t show up 2. You went to see if I was at the coffee shop I just left How many time do we go back and forth? That depends This is a real-life example of a race condition as things depend on the relative timing of events We may meet, we may not, luck in timing is involved

20 A POTENTIAL RACE CONDITION The Singleton Design Pattern ensure 1 instance It uses lazy initialization: a.k.a: check then act When do 2 threads call getinstance() below? it depends Maybe a 2 nd thread gets control before the assignment // NOTE: This is not thread safe! public class Singleton { private static Singleton uniqueinstance = null; private Singleton() { public static Singleton getinstance() { if (uniqueinstance == null) { uniqueinstance = new Singleton(); return uniqueinstance;

21 NEED MUTUAL EXCLUSION See linked list example on Wikipedia

22 THAT DEPENDS One thread could update and access a different object than the other thread, then there are two instances Or the 2 nd thread could gain access to that object while in a corrupt state (while it is being built) Like all race conditions, this lack of thread safety does not always result in an error To avoid race conditions, there must be a way to prevent other threads from using a variable while we re in the middle of modifying it This ensures other threads can observe and/or modify the state only before it begins or after it s done, but not in the middle.

23 ONE SOLUTION Mark getinstance() or LinkedList remove as synchronized // This is thread safe public class Singleton { private static Singleton uniqueinstance; private Singleton() { public static synchronized Singleton getinstance() { if (uniqueinstance == null) { uniqueinstance = new Singleton(); return uniqueinstance;

24 SYNCHRONIZED synchronized ensures that only a single thread can execute a method at one time synchronized methods provide 1. mutual exclusion: preventing other threads from seeing an object while it is being modified the object is in an inconsistent state 2. thread A knows about another thread B s changes Other threads are blocked out of the method until the thread finishes These threads are queued up for access, which they get when the synchronized method has finished

25 NOT ATOMIC Atomic: operation completes while locked Works in a single thread. Multithreaded? Maybe ++ is actually three operations getcount() may or may not return correct count it depends on the timing public class UnsafeCounting { private long count = 0; public long getcount() { return count; public void service() { // do stuff that take some millseconds ++count;

26 TO BE ATOMIC OR NOT TO BE import java.util.concurrent.atomic.atomiclong; public class SafeCounting { // AtomicLong is a Thread Safe class. private final AtomicLong count = new AtomicLong(0); public long getcount() { return count.get(); public void service() { // do stuff but block a 2nd thread until done count.incrementandget(); // Atomically incremented by one the current value

27 WHEN ARE CHANGES KNOWN? One thread sees the actual value of the fields (rather than some arbitrary value in memory) However, a value assigned to a field by one thread may not be visible to other threads The memory model defines when and how changes made by one thread become visible to others