Concurrency and Java Programming

Transcription

1 Concurrency and Java Programming What is Concurrent Programming? Concurrent programming involves using features of the Java VM that allow parts of your program to run in parallel with each other. This involves creating objects that implement threading and executing such objects in parallel. Normally, when you write a program using methods, and you execute a method, the program waits for the method to return before continuing. A thread would be like a method that, when called, starting running and your main program continues to execute after calling the method. The main program does not have to wait for the method to finish before continuing. The main reason for creating concurrent programs in Java is to solve specific problems. For example, a GUI program may want to read/write objects to a database but not perform such IO while the user is working with the GUI components. Another application would be network programming. A Server program designed to handle multiple incoming connections will likely need to create multiple threads to handle such connections. Processes and Threads There is a difference between a Process and a Thread. Typically, Processes are used by operating systems to perform concurrent actions. Windows has a print spooler process that will operate at the same time foreground programs are running. This allows you to print in the background. However, a Process normally has its own memory structure and stack. The Operating System manages such processes by separating them from each other so if a process crashes it won t affect other processes. The way such separation is done is by isolating processes in their own memory space. If a process needs to communicate with another process, it would use some operating system method such as inter-process communication pipelines. Threads are a lightweight type of Processes. A Thread exists within a Process. Threads share a common memory structure and stack and are separated by the virtual machine (this is why you see Threading more often in languages like Java and C#). Threads can more easily communicate with each other by sending messages to another named Thread. Creating and Using a Thread In Java, there is a Thread class which is used to create concurrent objects. This Thread class can be used in two ways; by inheriting your class from the Thread base class, or by using an Interface and causing your object to be executed from outside. The primary difference between these two methods of creating runnable objects is one of design. Using the Thread as a base class implies that your class is-a type of Thread. This inheritance requirement involves redesigning your class inheritance chain. A second way is to apply an interface to your class and write the methods need to start the object. You would then use an Executor class to start your object running. This method does not require that your class inherit from the base class Thread but that it implement an interface. This method is good for situations where you want to retrofit concurrency onto an existing class. Inheriting from Thread Class: In this method you create a class that extends the Thread class. This base class requires that your class override the method named run(). This is the method that will be executed when your object starts. When this method completes then your object stops running. The following simple program creates a class that extends the Thread class:

2 import java.util.*; import java.io.*; public class MainProgram public static void main(string[] args) MyThreadClass c1 = new MyThreadClass("Frank", 5000); MyThreadClass c2 = new MyThreadClass("Donna", 8000); c1.start(); c2.start(); while (true) if( c1.getnumlives() == 0 && c2.getnumlives()==0) break; System.out.println("All done"); class MyThreadClass extends Thread private String name; private int pausenum; private int numlives; public MyThreadClass(String n, int p) name = n; pausenum = p; numlives = 10; public int getnumlives() return numlives; public void run() while (numlives > 0) System.out.println("Hello: I am " + name); numlives--; try Thread.sleep(pausenum); catch (InterruptedException e) e.printstacktrace();

3 The class MyThreadClass extends Thread. The only method in Thread that must be overridden in the inheriting class is run() which is public and with returns void. The MyThreadClass takes two values for the Constructor, the thread object name and the number of pausing milliseconds. Each thread object will print its own name after pausing the specified number of milliseconds. Each thread object is also set with 10 lives. The Constructor for these Thread objects just sets these values. Once a thread object is created (in main() ) it must be started. This second step is necessary in order to kick-start the thread. When the start() method is called on the Thread object it initiates the run() method. You never directly call run() because the Thread class must initialize internal structures. The Thread class as defined contains a method to return the number of lives. Notice how the run() method is actually a loop using the while() structure. Inside the loop the run() method looks like: public void run() while (numlives > 0) System.out.println("Hello: I am " + name); numlives--; try Thread.sleep(pausenum); catch (InterruptedException e) e.printstacktrace(); While the number of lives in the Thread object are greater than zero then the method prints the name, reduces the number lives, and sleeps for the specified milliseconds. Notice that the method: Thread.sleep( xxx ) Is used to pause execution of the thread. This is a static method in the base Thread class and it must be called in a try/catch block. Using the Runnable Interface: A second way to create a concurrent object is to use the Runnable interface. This is an interface that is applied to a class. Once applied, the runnable object is passed to a new Thread object and the Thread object uses start(). The previous program has been rewritten to use the Runnable Interface: import java.util.*; import java.io.*; public class MainProgram public static void main(string[] args)

4 MyThreadClass c1 = new MyThreadClass("Frank", 5000); MyThreadClass c2 = new MyThreadClass("Donna", 8000); Thread x1 = new Thread(c1); x1.start(); Thread x2 = new Thread(c2); x2.start(); while (true) if( c1.getnumlives() == 0 && c2.getnumlives()==0) break; System.out.println("All done"); class MyThreadClass implements Runnable private String name; private int pausenum; private int numlives; public MyThreadClass(String n, int p) name = n; pausenum = p; numlives = 10; public int getnumlives() return numlives; public void run() while (numlives > 0) System.out.println("Hello: I am " + name); numlives--; try Thread.sleep(pausenum); catch (InterruptedException e) e.printstacktrace();

5 In this program everything looks almost the same except the MyThreadClass implements an Interface named Runnable. This Interface requires that the run() method be used. An instance of this Interface class is then created and passed into the constructor for a new Thread object. This object is then used to start the object. MyThreadClass c1 = new MyThreadClass("Frank", 5000); MyThreadClass c2 = new MyThreadClass("Donna", 8000); Thread x1 = new Thread(c1); x1.start(); Thread x2 = new Thread(c2); x2.start(); This may seem like a lot of extra work, but it does allow you to quickly modify an existing class by adding the Runnable interface (even if the class already has an Interface and is inherited from another class) and then writing a run() method. Starting this object can also be simplified. Notice that the Thread objects x1 and x2 are only used to start the runnable object. You can simply the above code with: (new Thread(c1)).start(); (new Thread(c2)).start(); Synchronization Threading often results in objects executing at the same time but referencing shared resources. For example, two or more objects may reference a shared object and both attempt to use the object. When this happens the shared object may not have the results that each thread object expects. For example: import java.util.*; import java.io.*; public class MainProgram public static void main(string[] args) TMsg m = new TMsg(); MyThreadClass c1 = new MyThreadClass("Frank", 5000, m); MyThreadClass c2 = new MyThreadClass("Donna", 100, m); (new Thread(c1)).start(); (new Thread(c2)).start(); while (true) if( c1.getnumlives() == 0 && c2.getnumlives()==0) break;

6 System.out.println("All done"); class TMsg private int count; public void inc() count++; public void dec() count--; public int getc() return count; class MyThreadClass implements Runnable private String name; private int pausenum; private int numlives; private TMsg mm; public MyThreadClass(String n, int p, TMsg m) name = n; pausenum = p; numlives = 10; mm = m; public int getnumlives() return numlives; public void run() while (numlives > 0) System.out.printf("Current value is %s for %d ",name,mm.getc()); mm.inc(); System.out.printf("Hello: I am %s - I read %d \n",name,mm.getc()); numlives--; try Thread.sleep(pausenum); catch (InterruptedException e) e.printstacktrace();

7 In this example, an object of the class TMsg is created and given to each thread object. Since this is an object what is given to each Thread object is a pointer. Each Thread object uses this TMsg object to call an increment method. These methods will make changes to the object. The problem is that other Thread objects are also making calls to the inc() method and the getc() methods. While one Thread object increments the shared value, the other may decrement. In order to ensure that the method, when it is called, is locked for a specific thread, the term synchronized is used to identify the method. class TMsg private int count; public synchronized void inc() count++; public synchronized void dec() count--; public synchronized int getc() return count; This term causes the Threading code to lock the method and prevent other Threads from accessing the method until it is done. Sample Program import java.util.*; import java.io.*; import java.io.*; public class MainProgram public static void main(string[] args) // make some books ArrayList<BookClass> myarr = new ArrayList<BookClass>(); myarr.add( makebook("isb111","book1","author1",45.55,2001) ); myarr.add( makebook("isb222","book2","author2",23.33,2000)); myarr.add(makebook("isb333","book3","author3",54.44,1999)); myarr.add(makebook("isb444","book4","author4",65.55,2000)); // make a book writer BookWriter bkwtr = new BookWriter(); bkwtr.setfile("mybooks.txt"); bkwtr.setarray(myarr); (new Thread(bkwtr)).start(); while( bkwtr.getflag() == false) System.out.println("Waiting"); System.out.println("Done with program");

8 public static BookClass makebook(string isbn, String title, String auth, double price, int pr) BookClass bk = new BookClass(); bk.setisbn(isbn); bk.settitle(title); bk.setauthor(auth); bk.setprice(price); bk.setpubdate(pr); return bk; class BookClass private String isbn; private String title; private String author; private double price; private int pubdate; public String gettitle() return title; public void settitle(string title) this.title = title; public String getauthor() return author; public void setauthor(string author) this.author = author; public double getprice() return price; public void setprice(double price) this.price = price; public int getpubdate() return pubdate;

9 public void setpubdate(int pubdate) this.pubdate = pubdate; public String getisbn() return isbn; public void setisbn(string isb) isbn = isb; class BookWriter implements Runnable private ArrayList<BookClass> bkarray; private BufferedWriter wtr; private boolean finished; public BookWriter() bkarray = null; wtr = null; finished = false; public boolean getflag() return finished; public void setfile(string fn) try wtr = new BufferedWriter( new FileWriter(fn) ); catch (IOException e) System.out.println("Error creating output file"); public void setarray(arraylist<bookclass> bk) bkarray = public void run() if( wtr==null)

10 finished=false; return; try for (BookClass bk: bkarray) // make output string String fmt = String.format("%s,%s,%s,%f,%d\n", bk.getisbn(),bk.getauthor(), bk.gettitle(),bk.getprice(),bk.getpubdate()); wtr.write(fmt); // pause for effect Thread.sleep(3000); wtr.close(); finished=true; catch (IOException e) System.out.println("Error writing books"); catch (InterruptedException e) System.out.println("Error in write thread"); wtr = null; This program creates a BookClass that stores book information. This class is used to create an array list of objects. A BookWriter class is also defined. This class uses the Runnable interface and therefore must contain a run() method. This method uses the internal ArrayList of book objects and writes each object out to an external file. There is a 3 second pause after each write. The main program will start this BookWriter object going with the command: (new Thread(bkwtr)).start(); Notice that a thread object is never saved and it is only created long enough to start the bookwriter object. The main program contains a loop that runs in parallel to the book writer object. This loop is: while( bkwtr.getflag() == false) System.out.println("Waiting");

11 The bookwriter object contains a flag (boolean) that is initially set to false. When the flag is flipped to true then the run() method has finished. This is a way to communicate from inside a runnable object; by using a flag. Using Threading The main areas where Thread based programs are used are in GUI programs and in networking programs. In the Networking lecture a sample program will be created that also uses Threads.