advanced topics chapter 13 chapter contents chapter objectives 13.1 introductory example: sorting a...
TRANSCRIPT
Chapter Contents
Chapter Objectives13.1 Introductory Example: Sorting a
List13.2 Topic: Multithreading13.3 Topic: Client-Server Networking13.4 Graphical/Internet Java: Moon
AnimationPart of the Picture: The TCP/IP
Communications Architecture13.5 The End?
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
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
Design
• First approach:Build an ArrayList of n random Integer values– measure time required for the sort
• Second approach:Build two ArrayList objects of n/2 random Integersa) measure time to sort first list using Sorter
object running as separate threadb) sort second list normallyc) merge the two into a single sorted list of
length n
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
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
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
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
Extending the Thread Class1. 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}
2. Have the normal thread create an instance of the class so definedListSorter secondSorter = new ListSorter (list1);
Extending the Thread Class3. Make this thread begin running
by sending it the start() message
secondSorter.start()Visualized below:
secondSorter = new ListSorter(list1);
secondSorter.start();
normal thread
2nd thread
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
Implementing the Runnable Interface1. 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
}
Implementing the Runnable Interface2. Have the normal class create an
instance of the class defined in 1.ListSorter secondSorter
ListSorter secondSorter = new ListSorter(list1);
3. Also have the class create a new instance of the Thread class
• initialized with object created aboveThread secondThread =
new Thread(secondSorter);
Implementing the Runnable Interface4. 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
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
"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
Non Atomic Operations in Separate Threads• Assume credit() and debit() are in
separate threads• Both will
1. read the balance2. create a temp value3. add to (or subtract from) the temp value4. 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 !!!
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;}
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
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
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
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
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
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 neededSocket S = new Socket(remoteHost, DAYTIME_PORT);
Reading form a Socket
• Connection alone not enough– must be able to read from it– considered an input operation
• Input stream declaredBufferedReader M = new BufferedReader(
new InputStreamReader(S.getInputStream() ));
• Input stream accessedtimeOfDay = M.readln();
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(" … ");
ServerSocket Initialization• Client socket initialization
– specify remoteHost and port
Socket 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
port
ServerSocket sS = new ServerSocket(port);
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()1. server sending the accept() blocks until a
client requests connection2. accept() builds, sends a Socket that is
the actual end-point for connection back to client
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
Closing a Socket
• Consider it a stream– closed with the close() commandmyReader.close();
• If socket not closed– programs can become "zombie
processes"
Example: A Daytime ServerBehavior1. Build ServerSocket to listen for
connections on port 10132. Repeat the following
a) use accept() to accept connection request
b) Build PrintWriter for resulting Socketc) Get current day, time from systemd) Write current day, time to PrintWritere) Close PrintWriter (and Socket)
Note source code, example of run, Figure 13.4
Note source code, example of run, Figure 13.4
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
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 loop
for( ; ; ) { Socket sessionSocket = myServerSocket.accept();// create new thread for service using// sessionSocket// start the thread}
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
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
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
Process States
• Running state (view on previous slide)• Paused state
– shows Backward, Forward, Play buttons– removes slider, pause
runningpaused
Pause pressed
Play pressed
Forward pressed
Backward pressed
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
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
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
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
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
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
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)
Most widely used
Most widely used
Organization of TCP/IP
Five relatively independent layers:1. Physical layer
• connects computer with network
2. Network access layer• concerned with access to and
routing data across a network for end systems
3. Internet layer• procedures for data to traverse
multiple interconnected networks
Organization of TCP/IP
Five relatively independent layers:4. Host-to-host layer or transport
layer• concerned with reliable data
exchange
5. Application layer• supports variety of applications• separate modules needed for each
application
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
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
TCP and UDP
• Note header format for TCP, Figure 13.13a
• UDP – User Datagram Protocol– provides connectionless service for
application-level procedures– does not guarantee delivery,
preservation of sequence, duplication protection
– provides message sending with minimum protocol
IP and IPv6
• Provides functional enhancements over current IP
• Accommodates higher transmission speeds, mixing of data streams
• Handles increasing number of addresses
TCP/IP Applications
• Simple mail transfer protocol (SMTP)– basic electronic mail– features include mailing lists, return
receipts, forwarding– uses TCP to send it to SMTP module
elsewhere
• File transfer protocol (FTP)– accommodates both text and binary
files– enables user access control
TCP/IP Applications
• TELNET provides remote logon capability– user at one computer can log on to
remote computer– user can function as if directly
connected to remote location– terminal traffic between user and
server carried on TCP connection