Advanced Topics

1. Advanced Topics Chapter 13

2. Chapter Contents Chapter Objectives 13.1 Introductory Example: Sorting a List 13.2 Topic: Multithreading 13.3 Topic: Client-Server Networking 13.4 Graphical/Internet Java: Moon Animation Part of the Picture: The TCP/IP Communications Architecture 13.5 The End?

3. Chapter Objectives • Study the use of threads in Java • Learn about Java's built in support for communication across a network • See an example of threads used in animations • Investigate the TCP/IP communications architecture

4. 13.1 Introductory Example: Sorting a List • Recall use of ArrayList and LinkedList classes • examples of collection classes • A Collections class also exists • one of its methods is sort() • given any List of objects that can be compared, it will arrange them in ascending order • Our example creates an ArrayList of 1,000,000 items • contrasts two different sort routines

5. Design • First approach:Build an ArrayList of n random Integer values • measure time required for the sort • Second approach:Build twoArrayList objects of n/2 random Integers • measure time to sort first list using Sorter object running as separate thread • sort second list normally • merge the two into a single sorted list of length n

6. Anticipated Results • On computer with single CPU, first method should be slightly faster • On computer with multiple CPUs, second method slightly faster • thread performing step a) runs on one CPU • step b) performed on different CPU • Program uses 10 trials and takes average times • Note source code, Figure 13.1 • the extends Thread portion of the declaration gives the ListSorter object its own thread of execution

7. Actual Results • On Pentium II uniprocessor • single-threaded sort took less time • double threaded routine must share processor • On Sun multiprocessor • two-threaded sort faster • multiple CPUs allow two threads to run simultaneously • give 30% faster results

8. 13.2 Topic: Multithreading Thread of Execution • When a program runs, it executes a series of statements • in sequence • some may be skipped in a branch • some may be repeated in a loop • This series is called a thread of execution

9. Multithreading • Programs studied until now are single-threaded • Java supports multithreaded programs • Advantages of multithreading • speeds up through parallel processing by dividing task into n pieces, each solved independently on separate processors • separates input tasks from processing tasks, processing thread can continue while input thread is blocked

10. Extending the Thread Class • Define a class that extends thread • contains a run() method to perform tasks in a separate thread class ListSorter extends Thread {// …public void run() { … }// statements the thread is to execute} • Have the normal thread create an instance of the class so definedListSorter secondSorter = new ListSorter (list1);

11. Extending the Thread Class • Make this thread begin running by sending it the start() message secondSorter.start() Visualized below: normal thread 2nd thread secondSorter = new ListSorter(list1); secondSorter.start();

12. Implementing the Runnable Interface • A class can extend only one other class • if a class needs to extend some non-Thread class and run as a distinct thread, the preceding approach will not work • Thus the Runnable interface approach

13. Implementing the Runnable Interface • Define a class that implements the Runnable interface • contains a run() method class ListSorter extends Whatever implements Runnable { // …public void run() { … }// statements that thread will execute }

14. Implementing the Runnable Interface • Have the normal class create an instance of the class defined in 1.ListSortersecondSorter ListSorter secondSorter = new ListSorter(list1); • Also have the class create a new instance of the Thread class • initialized with object created above Thread secondThread = new Thread(secondSorter);

15. Implementing the Runnable Interface • Send the new Thread object the start() message secondThread.start(); Note: this is a more complicated approach • used only to run a separate thread that must also extend a non Thread class

16. Synchronizing Accesses to Shared Data • Consider an Account class which provides debit and credit methods which change the balance • If multiple Transaction threads want to access the same Account object problems could arise

17. "Atomic" Operations • Operations that cannot be divided into "smaller" operations • Example: for myBalance being accessed by either the debit() or credit() methods at about the same time • these methods are not atomic at the byte-code level • each has about four separate steps

18. Non Atomic Operations in Separate Threads • Assume credit() and debit() are in separate threads • Both will • read the balance • create a temp value • add to (or subtract from) the temp value • replace the old balance with the temp value • If each step is happening at about the same time • each replaces the old balance with its own temp value without knowing about the action of the other, giving an incorrect new balance value !!!

19. Making Methods Atomic • Use the keyword synchronized to declare each method that accesses the critical information class Account{. . .synchronized public void debit(double amount) { … }synchronized public void credit(double amount { … }private myBalance;}

20. Making Methods Atomic • When a thread … • sends a synchronized message to an object • and … no other thread is executing a synchronized method on that object • Then … • Java locks the object • other synchronized methods cannot access the object until the first terminates

21. 13.3 Topic: Client-Server Networking • Java has built-in support for programs to communicate across a network • Client-server model has two kinds of programs • server programs that wait for other programs (clients) to request service • client programs that contact servers and ask them to perform a service

22. Client-Server Networking Example – web browsers • User clicks on a link, browser (client) program contacts server at that link site • Server retrieves requested file, sends it to browser (client) Modern e-mail programs work in a similar fashion

23. Sockets • Communication endpoints by which programs can send and receive information • Server creates a ServerSocket • waits for clients to connect to it • Client creates a Socket to connect to that server's ServerSocket

24. Socket Details • Sockets must be distinct from all others • Java requires special integer value, called a port • Ordered pair (ComputerName, portNumber) is the unique socket identification

25. Example: A Daytime Client • To illustrate how a Socket uses a port • Note source code for TCP daytime client, Figure 13.3 Features • Client Socket initialization • connects to ServerSocket at that time • Socket constructor needs name of remote host and port of socket needed Socket S = new Socket(remoteHost, DAYTIME_PORT);

26. Reading form a Socket • Connection alone not enough • must be able to read from it • considered an input operation • Input stream declared BufferedReader M = new BufferedReader(new InputStreamReader(S.getInputStream() )); • Input stream accessedtimeOfDay = M.readln();

27. Writing to a Socket • The server sending the data must declare the output stream PrintWriter W = new PrintWriter(S.getOutputStream(), true);// true enables auto-flush • Server then transmits the informationw.println(" … ");

28. ServerSocket Initialization • Client socket initialization • specify remoteHost and portSocket s = new Socket(remoteHost,port); • ServerSocket created by server • no remote host to be specified • specify port only • if 0 specified, sS will be given any free portServerSocket sS = new ServerSocket(port);

29. Accepting a Connection • The ServerSocket constructor builds, initializes an object • must also explicitly tell the object to listen for incoming connectionsSocket s = sS.accept() • Results of accept() • server sending the accept() blocks until a client requests connection • accept() builds, sends a Socket that is the actual end-point for connection back to client

30. Reading from, Writing to a ServerSocket • Done in same way as Socket is treated • Build a BufferedReader or PrintWriter • as a wrapper for the ServerSocket • Then use readLn() or println() • to communicate with the client

31. Closing a Socket • Consider it a stream • closed with the close() commandmyReader.close(); • If socket not closed • programs can become "zombie processes"

32. Example: A Daytime Server Behavior • Build ServerSocket to listen for connections on port 1013 • Repeat the following • use accept() to accept connection request • Build PrintWriter for resulting Socket • Get current day, time from system • Write current day, time to PrintWriter • Close PrintWriter (and Socket) Note source code, example of run, Figure 13.4

33. Multithreaded Servers • Program of Figure 13.4 is single-threaded • same thread accepts connect requests, then processes • uses a forever loop • Single thread here sufficient, quick response possible • Longer task would cause backlog of client requests

34. Multithreaded Servers • Each iteration of the processing loop will: • accept connection request • create a handler thread for that client • server thread immediately returns to top of processing loopfor( ; ; ) { Socket sessionSocket = myServerSocket.accept();// create new thread for service using// sessionSocket// start the thread}

35. Example: Multithreaded Echo Server • Server will read lines of text client sends • echo back each line • may be multiple lines, time consuming • EchoServer class • builds its ServerSocket • repeatedly invokes accept()creates new EchoHandler thread for each request

36. Echo Server • Source code for multithreaded echo server, Figure 13.5 • Echo-handler thread source code, Figure 13.6 • Echo Client program, figure 13.7 • Multithreading rule of thumb:If providing a server's service takes less time than creating a thread, then a single-threaded server should be used

37. 13.4 Graphical/Internet Java:Moon Animation • Application will present a stationary moon • use animation to show change of appearance over time • use "slider" to control speed of animation • use pause, play, forward, backward buttons

38. Behavior Moon Phases Faster Slower ||

39. Process States • Running state (view on previous slide) • Paused state • shows Backward, Forward, Play buttons • removes slider, pause Forward pressed Pause pressed running paused Backward pressed Play pressed

40. Strategy • Load images from file with getImage() command • Load images into an array • Iterate through array in circular fashion • display in sequence • Must also listen for user-generated events (buttons pushed) • Listening and animating at the same time requires two threads

41. Source Code • Note source code, Figure 13.8 • Getting the Images • in constructor, for loop • routine waits for all images before displaying, no flicker • Constructor also starts the thread in running state • paintComponent() method used to draw images

42. Source Code • Defining Thread behavior • run method repeatedly checks for pause and then increments image and repaints • Pausing execution • synchronized pause() method sets flag • synchronized waitIfPaused() method calls wait() • synchronized go() changes flag

43. Behind the Scenes • Java objects have an attribute called a "monitor" • Used for synchronization of methods • A class must "own the monitor" before it can execute a synchronized method • Synchronized methods each have a lock, checked when a thread seeks to execute • Thread suspended on "lock list" while waiting to own the monitor

44. Behind the Scenes • Consider a thread executing synchronized method which invokes wait() • thread gives up monitor • Java suspends thread on "waiting list" to be notified • left on waiting list until another synchronized thread sends notify() • notify() transfers thread to lock list to wait for re-acquisition of the monitor

45. MoonPhases Class • Note source code, Figure 13.9 • New feature used, slider controlmySlider = new JSlider(0,1000, INITIAL_DELAY); • implements ChangeListener interface • requires stateChanged() method • actionPerformed()method • determines which button pressed, • sends appropriate message to MoonAnimator

46. Most widely used Part of the Picture: The TCP/IP Communications Architecture • Universal standards have been adopted for interconnection software • Before standards developed, we need … • structure or protocol architecture • defines the communication tasks • Two current architectures • TCP/IP • OSI (Open Systems Interconnection)

47. Organization of TCP/IP Five relatively independent layers: • Physical layer • connects computer with network • Network access layer • concerned with access to and routing data across a network for end systems • Internet layer • procedures for data to traverse multiple interconnected networks

48. Organization of TCP/IP Five relatively independent layers: • Host-to-host layer or transport layer • concerned with reliable data exchange • Application layer • supports variety of applications • separate modules needed for each application

49. Operation of TCP/IP Consider a sample operation – application associated with port 1 at host A wishes to send message to another application, port 2, host A • Application gives message to CCP • send to host B, port 2 • TCP gives message to IP • send to host B (need not mention port) • note that control info and data may be broken into smaller blocks of data • blocks include TCP header and TCP segment • header can include destination port, sequence number, checksum

50. Operation of TCP/IP • IP hands message to network access layer • send it to router J • IP also appends header of control information • Network layer appends header, transmits packet to router • headers contain information needed for routing • include destination subnetwork address and facilities requests • At router, packet header removed, IP header examined • datagram directed to destination • At destination, reverse process occurs • headers removed at various levels • destination application receives message