multithread msc lecture

1. Engineering Technical college-ErbilDep. of ISE Application Building Software Construction Lecture Slides #9: Multi threading S1 2014 Asst.Prof.Dr.Raghad Z.Yousif

2. What is a Thread? • A thread is a single sequential flow of control within a program. • At any given time during the runtime of the thread, there is a single point of execution. • However, a thread itself is not a program; a thread cannot run on its own. Rather, it runs within a program.

3. Multithreading • Multiple threads can be executed at the same time within a single program. Such usage is called multi threading. • Each thread may perform a different task in a single program • Multiple threads create an illusion of several tasks being handled in parallel. Actually the processor allocates a fraction of its CPU cycle time to execute each thread.

4. Introduction: Where are Threads Used? • Threads are used by virtually every computer user in the following instances: • In Internet browsers • In databases • In operating systems (for controlling access to shared resources etc) • Benefits of threads • More productivity to the end user (such as responsive user interface) • More efficient use of the computer (such as using the CPU while performing input-output) • Sometimes advantageous to the programmer (such as simplifying program logic)

5. Creating Java Threads – Subclassing java.lang.Thread • There are two ways to create threads in java. Assume you have a class “MyClass” which may contain several tasks to be executed as threads. One of the ways to create and execute a threaded application is as follows: • “MyClass” should be declared to be a subclass of java.lang.Thread. • “MyClass” should override the run method (public void run()) of class Thread. • An instance of the “MyClass” can then be instantiated and executed as a thread using the start() method. • Note that the code to be executed as thread should be in the run() method of “MyClass”. • The following example shows how this can be done.

14. Example 1 • public class SimpleThread extends Thread { • private String title; • public SimpleThread(String str) { • this.title = str; • } • public void run() { • for (int i = 0; i < 10; i++) { • System.out.println(i + " " + title); • try { • sleep((long)(Math.random() * 1000)); • } catch (InterruptedException e) {} • } • System.out.println("DONE! " + getName()); • } • public static void main (String[] args) { • new SimpleThread("First Thread").start(); • new SimpleThread("Second Thread").start(); • } • }

15. Methods in java.lang.Thread • The run() method contains the code which has to be executed as threads. • The start() method is the method invoked in order for the threads to run in a multithreaded way. • As soon as a call to start() is made, the thread is created and starts execution. Control returns back immediately to the next statement in the program while the thread may be in execution. • Note that if a call new SimpleThread.run() is made, the run() method is executed in the current thread and the new thread is never started. Thread is created and execution begins ……………….. ……………… public static void main (String[] args) { new SimpleThread("First Thread").start(); new SimpleThread("Second Thread").start(); } Control returns back to the next statement before completion of the current statement.

16. Methods in java.lang.Thread – Contd. • The sleep() method (public static void sleep(long millis) throws InterruptedException) makes the current thread inactive for a specified number of milliseconds. • The InterruptedException is thrown when a thread is waiting, sleeping, or otherwise paused for a long time and another thread interrupts it using the interrupt() method in class Thread. • The getName() (public final String getName()) method returns back the name of the current thread as a String. • Every thread has a name (including anonymous threads) for identification purposes • More than one thread may have the same name • If a name is not specified when a thread is created, a new name is generated.

17. Creating Java Threads – Implementing java.lang.Runnable • Another way to create and execute Java threads is as follows. Assume you have a class “MyClass” which may contain several tasks to be executed as threads. • “MyClass” should implement the interface java.lang.Runnable • “MyClass” should implement the run method (public void run()) of the interface Runnable • An instance of the Thread class can be created using an instance of “MyClass” as a parameter as follows: Thread t = new Thread(new MyClass()); • Now the run() method of “MyClass” can be executed as a thread by invoking the start() method using t.start(). • Note that the code to be executed as thread should be in the run() method of MyClass. • The following example shows how this can be done.

18. Example 2 • import javax.swing.*; • public class TimeThread extends JFrame implements Runnable { • private JTextField sec, min, hrs; • private JPanel panel; • private int time = 0; • public TimeThread() • { • super(“Time"); • sec = new JTextField(3); sec.setEditable(false); //makes textfield uneditable • min = new JTextField(3); min.setEditable(false); • hrs = new JTextField(3); hrs.setEditable(false); • panel = new JPanel(); • panel.add(hrs); panel.add(min); panel.add(sec); • getContentPane().add(panel); pack(); setVisible(true); • }

19. Example – Contd. 22. public void run() 23. { 24. try { 25. while(true) { 26. Thread.sleep(1000); time++; 27. sec.setText(time%60 + ""); //Display seconds 28. min.setText((time – (time/3600)*3600)/60 + ""); //Display minutes 29. hrs.setText(time/3600 + ""); //Display hours 30. } 31. } catch(InterruptedException e) {} 32. } 33. 34. public static void main(String[] args) 35. { 36. TimeThread t = new TimeThread(); 37. Thread mytime = new Thread(t); 38. mytime.start(); 39. } 40.}

20. Thread Priority • Execution of multiple threads on a single CPU in some order is called scheduling. • The Java runtime environment supports a very simple, deterministic scheduling algorithm called fixed-priority scheduling. This algorithm schedules threads on the basis of their priority relative to other Runnable threads. • Thread priorities are integers ranging between MIN_PRIORITY and MAX_PRIORITY (constants defined in the Thread class). • At any given time, when multiple threads are ready to be executed, the runtime system chooses for execution the Runnable thread that has the highest priority. • If two threads of the same priority are waiting for the CPU, the scheduler arbitrarily chooses one of them to run.

21. Thread Priority • The values of constants in java.lang.Thread are as follows: • The methods int getPriority() and setPriority(int priority) are used the accessor and mutator methods used for the priority of a Java thread. • The default priority value of a thread is 5 (java.lang.NORM_PRIORITY) or it is the priority of the thread that constructed it.

22. Thread Priority – Example 1 • public class SimplePThread extends Thread { • public SimplePThread(String str) { • super(str); //Thread can be created using a string • } • public void run() { • for (int i = 1; i < 400; i++) { • for(int j = 0; j < 40000; j++) • System.out.print(""); //Keeps thread busy • System.out.print(getName()); • } • System.out.print("."); • } • public static void main (String[] args) { • Thread t1 = new SimplePThread("1"); • Thread t2 = new SimplePThread("2"); • t1.setPriority(Thread.NORM_PRIORITY + 1); • t2.setPriority(Thread.NORM_PRIORITY - 1); • System.out.println("Thread 1 has priority " + t1.getPriority()); • System.out.println("Thread 2 has priority " + t2.getPriority()); • t1.start(); t2.start(); • } • }

30. The interrupt() method • The interrupt() method (public void interrupt()) interrupts the current thread. If thread is inactive, an InterruptedException is thrown which must be caught. • The isInterrupted() method (public boolean isInterrupted()) checks if the current thread is interrupted or not. • An example shows their use.

31. Example 2 • import javax.swing.*; • import java.awt.event.*; • public class TimeThread3 extends JFrame implements ActionListener { • private JTextField sec, min, hrs; private JButton button; private JPanel panel; • private TimerTh t; private int time = 0; • public TimeThread3() • { • super("Time"); • sec = new JTextField(3); sec.setEditable(false); • min = new JTextField(3); min.setEditable(false); • hrs = new JTextField(3); hrs.setEditable(false); • button = new JButton("Stop"); button.addActionListener(this); • panel = new JPanel(); panel.add(hrs); panel.add(min); panel.add(sec);panel.add(button); • getContentPane().add(panel); pack(); setVisible(true); • t = new TimerTh(); t.start(); • }

32. Example 2 – Contd. 24. class TimerTh extends Thread //Inner Class 25. { public void run() • { try • { 27. while(true) 28. { Thread.sleep(1000); time++; 29. sec.setText(time%60 + ""); //Display seconds 30. min.setText((time - (time/3600)*3600)/60 + ""); //Display minutes 31. hrs.setText(time/3600 + ""); //Display hours 32. } 33. } catch(InterruptedException e) { System.out.println("Timer Stops"); } 34. } 35. } • Here the Thread appears as an Inner Class. • Compare this with the example 2 of the previous lecture in which the thread was implemented by implementing the Runnable interface. • As an Inner Class the thread can access the textfields hrs, min and sec of the enclosing class. • Both usages are acceptable.

33. Example 2 – Contd. 36. public void actionPerformed(ActionEvent e) 37. { • t.interrupt(); //Stop the timer • if(t.isInterrupted()) //If successful, • { • JOptionPane.showMessageDialog(this, • "Time stopped " + hrs.getText() + ":" + min.getText() + ":" + sec.getText()); 42. System.exit(0); 43. } 44. } 45. 46. public static void main(String[] args) { new TimeThread3(); } 47. }

34. Thread Synchronization • When two or more threads access a shared resource, (for example a variable), the resource may be corrupted e.g., unsynchronized threads accessing the same database • Such blocks of code are usually called critical sections and must be executed in a mutually-exclusive way • When a block of Java code guarded by the synchronized keyword, it can be executed by only one thread at any time • You can synchronize an entire method or just a few lines of code by using the synchronized keyword • Note that code that is thread-safe (i.e, guarded by synchronized) is slower than code that is not. • Next, we present an example which shows problems due to shared thread access and then the synchronized thread version.

35. Example 2

36. Thread Synchronization • When the program is executed, it may produce erroneous output. • This is because many threads are executing the method depositWithdraw(int money) and get() at the same time. • So it may be possible that while one thread is incrementing the variable balance, many others are decreasing it and vice versa. • In the output snapshot shown here, at one point the balance is 190 although practically the user deposits and withdraws a maximum amount of 30 each time.

37. Thread Synchronization • One solution to the problem pointed out is to use the synchronized keyword with all methods that deal with the variable balance. • This is to ensure that only one thread accesses the variable balance at a time. • Other threads may wait() while one thread is accessing and modifying the variable balance. The method wait() is inherited by the class java.lang.Thread from the class java.lang.Object. • When the thread accessing and modifying the variable balance is done, it may notifyAll() threads waiting to execute the synchronized methods. • The complete correct program appears on the next slide.

38. Example 3

39. Threads Animation • In addition to applications in accessing databases, threads can also be used to create animations. • In the next example we show a program where a thread is used to create an animation of a ball moving vertically. • The run() method increments the y coordinate of the ball to be drawn. If the y-coordinate exceeds the height of the window, the ball is reflected back by negating the increment. • The complete program appears in the next slide.

40. Example 4 – Thread Animations