1 / 55

Advanced Topics

Advanced Topics. Chapter 13. 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

sueh
Download Presentation

Advanced Topics

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  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

More Related