Prof. Marlon A Santos Prof. Marlon A Santos Gestão Ambiental e Responsabilidade Social.
1 e-Science e-Business e-Government and their Technologies Advanced Java Bryan Carpenter, Geoffrey...
-
Upload
homer-burke -
Category
Documents
-
view
215 -
download
0
Transcript of 1 e-Science e-Business e-Government and their Technologies Advanced Java Bryan Carpenter, Geoffrey...
11
e-Science e-Business e-Government and their
TechnologiesAdvanced Java
Bryan Carpenter, Geoffrey Fox, Marlon PiercePervasive Technology Laboratories
Indiana University Bloomington IN 47404January 12 2004
[email protected]@indiana.edu
[email protected] http://www.grid2004.org/spring2004
22
What are we doing This is a semester-long course on Grids (viewed as technologies
and infrastructure) and the application – mainly to science but also to business and government
We will assume a basic knowledge of the Java language and then interweave 6 topic areas – first four cover technologies that will be used by students
1) Advanced Java: including networking, Java Server Pages and perhaps servlets
2) XML: Specification, Tools, Linkage to Java 3) Web Services: Basic Ideas, WSDL, Axis and Tomcat 4)Grid Systems: GT3/Cogkit, Gateway, XSOAP, Portlet 5) Advanced Technology Discussions: CORBA as istory, OGSA-
DAI, security, Semantic Grid, Workflow 6) Applications: Bioinformatics, Particle Physics, Engineering,
Crises, Computing-on-demand Grid, Earth Science
33
Course Topic 1 Advanced Java Programming
• We will assume basic Java programming proficiency
• We will cover Java client/server, three-tiered and network programming.
• Ancillary but interesting Java topics to be covered include Apache Ant, XML-Beans, and Java Message Service
Material in the last bullet will mostly be introduced in later sections, as the course unfolds.
First lecture of the segment starts with a fairly discursive review of Java features.
44
Reading Material No particular text for this section, but some material
will come from earlier related courses:• Java HPC Course, September 2003
http://www.hpjava.org/courses/arl
• Opennet Technologies Online Course, Fall 2001
http://aspen.ucs.indiana.edu/ptliu
• Applications of Information Technology I and II, Spring 2001
http://aspen.ucs.indiana.edu/it1spring01
http://aspen.ucs.indiana.edu/it2spring01
55
Java History The Java language grabbed public attention in 1995,
with the release of the HotJava experimental Web browser, and the subsequent incorporation of Java into the Netscape browser.• Java had originally been developed—under the name of Oak
—as an operating environment for PDAs, a few years before.
Very suddenly, Java became one of the most important programming languages in the industry.• The trend continued. Although Web applets are less
important today than they were originally, Java was rapidly adopted by many other sectors of the programming community.
66
The Java Virtual Machine Java programs are not compiled to machine code in
the same way as conventional programming language. To support safe execution of compiled code on
multiple platforms (portability, security), they are compiled to instructions for an abstract machine called the Java Virtual Machine (JVM).• The JVM is a specification originally published by Sun
Microsystems.• JVM instructions are called Java byte codes. They are
stored in a class file.• This execution model is part of the specification of the Java
platform. There are a few compilers from the Java language to machine code, but it is hard to get these recognized as “Java compliant”.
77
JVM and Performance The first implementations of the JVM simply
interpreted the byte codes. These implementations were very slow.• This led to a common misconception that Java is an
interpreted language and inherently slow. Modern JVMs normally perform some form of
compilation from byte codes to machine code on the fly, as the Java program is executed.
88
Run-time Compilation In one form of Just-In-Time compilation, methods may be
compiled to machine code immediately before they are executed for the first time. Then subsequent calls to the method just involve jumping into the machine code.
More sophisticated forms of adaptive compilation (like in the Sun Hotspot JVMs) initially run methods in interpreted mode, monitor program behavior, and only spend time compiling portions of the byte code where the program spends significant time. This allows more intelligent allocation of CPU time to compilation and optimization.
Modern JVMs (like the Hotspot server JVM) implement many of the most important kinds of optimization used by the static compilers of “traditional” programming languages.• Adaptive compilation may also allow some optimization approaches that
are impractical for static compilers, because they don’t have the run-time information.
99
Features of the Java Language
1010
Prerequisites We assume you know either Java or C++ moderately
well.• But some things, like threaded and network programming
with Java, will be covered from an introductory level later on. In this section I will only point out some features and
terminologies that are characteristic of Java and that you probably should understand.• And highlight some of the differences from C++.
1111
What Java Isn’t C++, mainly—now hard to think of languages as closely related.
• Similar syntax for expressions, control constructs, etc, but these are perhaps the least characteristic features of C++ or Java.
In C++ use features like operator overloading, copy constructors, templates, etc, to create “little languages” through class libraries.• Worry about memory management and efficient creation of objects.• Worry about inline versus virtual methods, pointers versus references,
minimizing overheads. In Java most of these things go away.
• Minimal control over memory management, due to automatic garbage collection.
• Highly dynamic : all code is loaded dynamically on demand; implicit run-time descriptors play an important role, through run-time type checks, instanceof, etc.
• Logically all methods are virtual; overloading and implementation of interfaces is ubiquitous.
• Exceptions, rarely used in C++, are used universally in Java.
1212
Java Class Structure All methods and (non-local) variables are
explicitly member of classes (or interfaces).• No default, global, namespace (except for the names of
classes and interfaces). Java discards multiple inheritance at the class
level. Inheritance relations between classes are strictly tree-like. • Every class inheritance diagram has the universal base
class Object at its root.
1313
Java Class Structure (2) Java introduces the important idea of an interface,
which is logically different from a class. Interfaces contain no implementation code for the methods they define.• Multiple inheritance of interfaces is allowed, and this is
one way Java manages without it at the class level. Since Java 1.2, classes and interfaces can be
nested.• This is a big change to the language: read JLS 2nd
Edition in detail if you don’t believe this!
1414
Classes and Instances Will consistently use the following terminologies
(which are “correct”):• A class is a type, e.g.
public class A {int x ; void foo() {x = 23 ;}}• An interface is a type, e.g .
public interface B {void goo() ;}• An instance is an object. An object is always an
instance of one particular class. That class may extend other classes, and implement
multiple interfaces.
1515
Pointers in Java? Any expression in Java that has class type (or
interface type) is a reference to some instance (or it is a null reference). E.g. a variable declared: A a ;
holds a reference to an instance. The objects themselves are “behind the scenes” in Java: we can only manipulate pointers (references) to them.• E.g. a = b ; Only copies a reference, not an object.
But important to note references to objects and arrays are the only kinds of pointer in Java. E.g. there are no pointers to fields or array elements or local variables.
1616
Instance and static members The following terminologies are common. In:
public class A {
int x
void foo() {…}
static int y ;
static void goo() {…}
}
We say:x is an or instance variable, or non-static field.
foo() is an instance method, or non-static method.
y is a static field, or class variable.
goo() is a static method, or class method.
1717
Class Loading A Java program is typically written as a class with a public,
static, void, main() method, as followspublic class MyProgram { public static void main(String [] args) { … body of program … }}
and started by a command like:$ java MyProgram
This command creates a Java Virtual Machine, loads the class MyProgram into the JVM, then invoke its main() method.
As this process unfolds, dependencies on other class and interfaces and their supertypes will be encountered, e.g. through statements that use other classes. The class loader brings in the class files for these types on demand. Code is loaded, and methods linked, incrementally, throughout execution.
1818
The CLASSPATH Many people have problems getting the
CLASSPATH environment variable right.• Because all linking is done at run-time, must ensure
that this environment variable has the right class files on it.
The class path is a colon-separated (semicolon-separated in Windows) list of directories and jar files.• If the class path is empty, it is equivalent to “.”. But if
the class path is not empty, “.” is not included by default.
• A directory entry means a root directory in which class files or package directories are stored; a jar entry means a jar archive in which class files or package directories are stored.
1919
Binary Compatibility There is a useful property called binary-
compatibility between classes. This means that (within some specified limits) two class files that implement the same public interface can be used interchangeably.• It also means that if you pick up an inappropriate
implementation of a given class from the CLASSPATH at runtime, things can go wrong in an opaque way.
2020
Java Native Interface Some methods in a class may be declared as native
methods, e.g.:class B { public native long add(int [] nums) ;}
Notice the method add() has the modifier native, and the body of the method declaration is missing• It is replaced by a semicolon—similar to abstract methods in
interfaces, etc. But in this case the method isn’t abstract.• The implementation of a native method will be given in
another language, typically C or C++ (we consider C). Implementing native methods is quite involved.
• Arguably a good thing—it discourages casual use! Generally need a good reason for resorting to JNI.
2121
A Definition of Java_B_add()JNIEXPORT jlong JNICALL Java_B_add(JNIEnv * env, jobject this, jintArray nums) { jint *cnums ; int i, n ; jlong sum = 0 ;
n = (*env)->GetArrayLen(env, nums) ;
cnums = (*env)->GetIntArrayElements(env, nums, NULL) ;
for(i = 0 ; i < n ; i++) sum += cnums [i] ; return sum ;}
2222
The Invocation API JNI also provides a very powerful mechanism for going
the other way—calling from a C program into Java. First the C program needs to create a JVM (initialize all
the data structures associated with a running JVM), which it does with a suitable library call.
The standard java command works exactly this way—it uses the JNI invocation API to create a JVM, and call the main() method of the class specified on the command line.
2323
The Rest of this Segment Will cover three core topics in “advanced Java”:1. Multithreaded Programming in Java
• Java as a multithreaded language; Java thread synchronization primitives.
2. Network Programming in Java• Traditional Java class libraries for sockets, URLs.• Overview of Java “New I/O”.
3. Java Servlets and Java Server Pages.• Java technologies for “Web Applications”.
Other Java techniques (e.g. Java for XML, Web Services) will be introduced as the course unfolds.
2424
1) Multithreaded Programming in Java
2525
Need for Concurrent Programming This course is mostly about distributed programming.
• This is a different discipline from concurrent or multithreaded programming, but doing distributed programming without understanding concurrent programming is error prone.
• Some frameworks (e.g. EJB) try to enable distributed programming while insulating the programmer from the difficulties of concurrent programming, but eventually you are likely to hit concurrency issues.
Sequential programming
Concurrent programming
Distributed programming
+ Non-determinism + Partial failures
2626
Java as a Threaded Language In C, C++, etc it is possible to do multithreaded
programming, given a suitable library.• e.g. the pthreads library.
Unlike other languages, Java integrates threads into the basic language specification in a much tighter way.• Every Java Virtual Machine must support threads.
2727
Features of Java Threads Java provides a set of synchronization primitives
based on monitor and condition variable paradigm of C.A.R. Hoare.• Underlying functionality similar to e.g. POSIX threads.
Syntactic extension for threads (deceptively?) small:• synchronized attribute on methods.
• synchronized statement.
• volatile keyword.
• Other thread management and synchronization captured in the Thread class and related classes.
But the presence of threads has a wide-ranging effect on language specification and JVM implementation.
2828
Contents of this Lecture Introduction to Java Threads.
• Mutual Exclusion.
• Synchronization between Java Threads using wait() and notify().
• Other features of Java Threads. Suggested Exercises
2929
Java Thread Basics
3030
Threads of Execution Every statement in a Java program is executed in a
context called its thread of execution. When you start a Java program in the normal way, the
main() method—and any methods called from that method—are executed in a singled out (but otherwise ordinary) thread sometimes called the main thread.
Other threads can run concurrently with the main thread. These threads share access to the same classes and objects as the main thread, but they execute asynchronously, in their own time.
The main thread can create new threads; these threads can create further threads, etc.
3131
Creating New Threads Any Java thread of execution (including the main
thread) is associated with an instance of the Thread class. Before starting a new thread, you must create a new instance of this class.
The Java Thread class implements the interface Runnable. So every Thread instance has a method:
public void run() { . . . }
When the thread is started, the code executed in the new thread is the body of the run() method.• Generally speaking the new thread ends when this
method returns.
3232
Making Thread Instances There are two ways to create a thread instance (and define the
thread run() method). Choose at your convenience:
1. Extend the Thread class and override the run() method, e.g.:
class MyThread extends Thread {
public void run() { System.out.println(“Hello from another thread”) ; }}. . .Thread thread = new MyThread() ;
2. Create a separate Runnable object and pass to the Thread constructor:
class MyRunnable implements Runnable {
public void run() { System.out.println(“Hello from another thread”) ; }}. . .Thread thread = new MyThread(new MyRunnable()) ;
3333
Starting a Thread Creating the Thread instance does not in itself start the
thread running. To do that you must call the start() method on the new
instance: thread.start() ;
This operation causes the run() method to start executing concurrently with the original thread.
In our example the new thread will print the message “Hello from another thread” to standard output, then immediately terminate.
You can only call the start() method once on any Thread instance. Trying to “restart” a thread causes an exception to be thrown.
3434
Example: Multiple Threadsclass MyThread extends Thread {
MyThread(int id) { this.id = id ; }
public void run() { System.out.println(“Hello from thread ” + id) ; }
private int id ;}. . .
Thread [] threads = new Thread [p] ;
for(int i = 0 ; i < p ; i++) threads [i] = new MyThread(i) ;
for(int i = 0 ; i < p ; i++) threads [i].start() ;
3535
Remarks This is one way of creating and starting p new threads to
run concurrently. The output might be something like (for p = 4):
Hello from thread 3
Hello from thread 4
Hello from thread 2
Hello from thread 1
Of course there is no guarantee of order (or atomicity) of outputs, because the threads are concurrent.
One might worry about the efficiency of this approach for large numbers of threads (massive parallelism).
3636
JVM Termination and Daemon Threads
When a Java application is started, the main() method of the application is executed in the main thread.
If the main method never creates any new threads—the JVM keeps running until the main() method completes (and the main thread terminates).• Typically, the java command finishes.
If main() creates new threads, by default the JVM terminates when all user-created threads have terminated.
More generally there are system threads executing in the background (e.g. threads might be associated with garbage collection). These are marked as daemon threads—meaning that they don’t have the property of “keeping the JVM alive”. So actually the JVM terminates when all non-daemon threads terminate.• Ordinary user threads can create daemon threads by applying the
setDaemon() method to the thread instance before starting it.
3737
Mutual Exclusion
3838
Avoiding Interference In any non-trivial multithreaded (or shared-memory-
parallel) program, interference between threads is an issue. Generally interference (or a race condition) occurs if two
threads are trying to do operations on the same variables at the same time. This often results in corrupt data.• But not always. It depends on the exact interleaving of instructions.
This non-determinism is the worst feature of race conditions.
A popular solution is to provide some kind of lock primitive. Only one thread can acquire a particular lock at any particular time. The concurrent program can be written so that operations on some given variables are only performed by threads holding the lock for those variables.• In POSIX threads, for example, the lock objects are called mutexes.
3939
Monitors Java adopts a version of monitors, proposed by C.A.R. Hoare. Every Java object is created with its own lock (and every lock is
associated with an object—there is no way to create an isolated mutex). In Java this lock is often called the monitor lock.
Methods of a class can be declared to be synchronized. The object’s lock is acquired on entry to a synchronized method,
and released on exit from the method.• Synchronized static methods need slightly different treatment.
If methods generally modify the fields (instance variables) of the method instance, this leads to a natural and systematic association between locks and the variables they guard.
The critical region is the body of the synchronized method.
4040
Example use of Synchronized Methods
… call to counter.increment() …
// body of synchronized methodtmp1 = count ;count = tmp1 + 1 ;
… counter.increment() returns …
… call to counter.decrement() …
… counter.decrement() returns …
Blocked
Thread A Thread B
// body of synchronized methodtmp2 = count ;count = tmp2 - 1 ;
4141
Caveats This approach helps to encourage good practices, and make
multithreaded Java programs less error-prone than, say, multithreaded C programs.
But it isn’t magic—it still depends on correct identification of the critical regions, to avoid race conditions.
Concurrent programming is hard, and if you start with the assumption Java somehow makes concurrent programming “easy”, you are probably going to write some broken programs!
4242
Example: A Simple Queuepublic class SimpleQueue {
public synchronized void add(Object data) { if (front != null) { back.next = new Node(data) ; back = back.next ; } else { front = new Node(data) ; back = front ; } }
public synchronized Object rem() { Object result = null ; if (front != null) { result = front.data ; front = front.next ; } return result ; }
private Node front, back ;}
4343
Remarks This queue is implemented as a linked list with a front
pointer and a back pointer.• The method add() adds a node to the back of the list; the
method rem() removes a node from the front of the list.• The rem() method immediately returns null when the queue is
empty. The Node class just has a data field (type Object) and a
next field (type Node). The following slide gives an example of what could go
wrong without mutual exclusion. It assumes two threads concurrently add nodes to the queue.• In the initial state, Z is the last item in the queue. In the final
state, the X node is orphaned, and the back pointer is null.
4444
The Need for Synchronized Methods
back.next = new Node(X) ;
back = back.next ;
Thread A: add(X)
Thread B: add(Y)
back.next = new Node(Y) ;
back = back.next ;
Z null
back
Z
null
back
X
Z
null
back
X
nullY
Z
null
back
X
nullY
Z
null
back
X
nullY
null
Corrupt data structure!
4545
The synchronized construct The keyword synchronized also appears in the
synchronized statement, which has syntax like:
synchronized (object) { … critical region … }• Here object is a reference to any object. The synchronized
statement first acquires the lock on this object, then executes the critical region, then releases the lock.
• Typically you might use this for the lock object, somewhere inside a non-synchronized method, when the critical region is smaller than the whole method body.
• In general, though, the synchronized statement allows you to use the lock in any object to guard any code.
4646
Deadlock Deadlock occurs when a group of threads are mutually waiting
for one another in such a way that none can proceed.• This happens if there is a cycle of waits-for dependencies, e.g.
A waits for B, B waits for C, … , D waits for A.
There are unfortunately many ways this can occur. One common situation is if two threads try to acquire the same pair of locks in different orders, e.g.:
Thread A
synchronized(x) { …
synchronized(y) { … }}
Thread B
synchronized(y) { …
synchronized(x) { … }}
4747
Performance Cost of synchronized Acquiring locks introduces an overhead in execution
of synchronized methods. See, for example:“Performance Limitations of the Java Core Libraries”,Allan Heydon and Marc Najork (Compaq),Proceedings of ACM 1999 Java Grande Conference.
Many of the original utility classes in the Java platform (e.g. Vector, etc) were specified to have synchronized methods, to make them safe for the multithreaded environment.
This was probably a mistake: newer replacement classes (e.g. ArrayList) don’t have synchronized methods—the programmer provides synchronization as needed, e.g. through wrapper classes.
4848
General Synchronization
4949
Beyond Mutual Exclusion The mutual exclusion provided by synchronized
methods and statements is an important category of synchronization.
But there are other interesting forms of synchronization between threads. Mutual exclusion by itself is not enough to implement these more general sorts of thread interaction (not efficiently, anyway).
POSIX threads, for example, provides a second kind of synchronization object called a condition variable to implement more general inter-thread synchronization.
In Java, condition variables (like locks) are implicit in the definition of objects: every object effectively has a single condition variable associated with it.
5050
A Motivating Example Consider the simple queue from the previous example. If we try to remove an item from the front of the queue
when the queue is empty, SimpleQueue was specified to just return null.
This is reasonable if our queue is just meant as a data structure buried somewhere in an algorithm. But what if the queue is a message buffer in a communication system?
In that case, if the queue is empty, it may be more natural for the “remove” operation to block until some other thread added a message to the queue.
5151
Busy Waiting One approach would be to add a method that polls the queue
until data is ready:public synchronized Object get() {
while(true) {
Object result = rem() ; if (result != null) return result ; }}
This works, but it may be inefficient to keep doing the basic rem() operation in a tight loop, if these machine cycles could be used by other threads.• This isn’t clear cut: sometimes busy waiting is the most efficient solution.
Another possibility is to put a sleep() operation in the loop, to deschedule the thread for some fixed interval between polling operations. But then we lose responsiveness.
5252
wait() and notify() In general a more elegant approach is to use the
wait() and notify() families of methods. These are defined in the Java Object class.
Typically a call to a wait() method puts the calling thread to sleep until another thread wakes it up again by calling a notify() method.• We will speak of wait() putting a thread to sleep inside a
particular object, meaning we use the condition variable associated with that object. The notify() call that subsequently wakes the thread must be called on the same object.
5353
wait() and notify() II In our example, if the queue is currently empty, the
get() method would invoke wait(). This causes the get() operation to block.
Later when another thread calls add(), putting data on the queue, the add() method invokes notify() to wake up any “sleeping” thread. The original get() call can then return.
5454
A Simplified Examplepublic class Semaphore {
int s ;
public Semaphore(int s) { this.s = s ; }
public synchronized void add() {
s++ ;
notify() ; }
public synchronized void get() throws InterruptedException {
while(s == 0) wait() ;
s-- ; } }
5555
Remarks I Rather than a linked list we have a simple counter,
which is required always to be non-negative.• add() increments the counter.• get() decrements the counter, but if the counter was zero
it blocks until another thread increments the counter. The data structures are simplified, but the
synchronization features used here are essentially identical to what would be needed in a blocking queue (left as an exercise).
Some may recognize this as an implementation of a classical semaphore—an important synchronization primitive in its own right.
5656
Remarks II wait() and notify() should be used inside synchronized
methods of the object they are applied to.• More precisely, the calling thread must hold the object’s
monitor lock. The wait() operation “pauses” the thread that calls it.
It also releases the lock that the thread holds on the object, for the duration of the wait() call.• The lock must be claimed again, before continuing after
the pause. While the lock is “temporarily” released, another
synchronized method can proceed.• This method may wake up the first, by calling notify().
5757
Remarks III Several threads can wait() simultaneously in the
same object.• If any threads are waiting in the object, the notify()
method “wakes up” exactly one of those threads. If no threads are waiting in the object, notify() does nothing.
Common lore has it that one should always put a wait() call in a loop, in case the condition that caused the thread to sleep has not been resolved when the wait() completes.• The logic in the example here doesn’t strictly require it—
an if would also work. A wait() method may throw an InterruptedException
(rethrown by get() in the example). This will be discussed later.
5858
Another Examplepublic class Barrier {
private int n, generation = 0, count = 0 ;
public Barrier(int n) { this.n = n ; }
public synchronized void synch() throws InterruptedException {
int genNum = generation ; count++ ; if(count == n) { count = 0 ; generation++ ; notifyAll() ; } else while(generation == genNum) wait() ; }
}
5959
Remarks This class implements barrier synchronization—an important
operation in shared memory parallel programming. It synchronizes n processes: when n threads make calls to synch()
the first n-1 block until the last one has entered the barrier. The method notifyAll() generalizes notify(). It wakes up all
threads currently waiting on this object.• Many authorities consider use of notifyAll() to be “safer” than notify(),
and recommend always to use notifyAll(). In the example, the generation number labels the current,
collective barrier operation: it is only really needed to control the while loop round wait().• And this loop is only really needed to conform to the standard pattern of
wait()-usage, mentioned earlier.
6060
Final Remarks on Synchronization We illustrated with a couple of simple examples that
wait() and notify() allow various interesting patterns of thread synchronization (or thread communication) to be implemented.
In some sense these primitives are sufficient to implement “general” concurrent programming—any pattern of thread synchronization can be implemented in terms of these primitives. • For example you can easily implement message passing
between threads (left as an exercise…) This doesn’t mean these are necessarily the last word in
synchronization: e.g. for scalable parallel processing one would like a primitive barrier operation more efficient than the O(n) implementation given above.
6161
Other Features of Java Threads
6262
Other Features This lecture isn’t supposed to cover all the details—for
those you should look at the spec! But we mention here a few other features you may find
useful.
6363
Join Operations The Thread API has a family of join() operations. These
implement another simple but useful form of synchronization, by which the current thread can simply wait for another thread to terminate, e.g.:
Thread child = new MyThread() ;
child.start() ;
… Do something in current thread …
child.join() ; // wait for child thread to finish
6464
Priority and Name Thread have properties priority and name, which can be
defined by suitable setter methods, before starting the thread, and accessed by getter methods.
6565
Sleeping You can cause a thread to sleep for a fixed interval
using the sleep() methods. This operation is distinct from—and less powerful than
—wait(). It is not possible for another thread to prematurely wake up a thread that was paused using sleep().• If you want to sleep for a fixed interval, but allow another
thread to wake you beforehand if necessary, use the variants of wait() with timeouts instead.
6666
Deprecated Thread Methods There is a family of methods of the Thread class that was
supposed to give “life-or-death” control over threads. Experience showed these didn’t really work, and killing
threads is no longer considered acceptable in polite society. If you need to interrupt a running thread, you should explicitly
write the thread it in such a way that it pays attention to interrupt conditions (see the next slide) and terminates itself.• If you want to run an arbitrary thread in such a way that it can be
killed and garbage collected by an external agent, you probably need to fork a separate process, not a thread.
The deprecated methods include stop(), destroy(), suspend(), and resume().
6767
Interrupting Threads Calling the method interrupt() on a thread instance
requests cancellation of the thread execution.• This works in an advisory way: the code for the thread must
explicitly test whether it has been interrupted, e.g.:public void run() { while(!interrupted()) … do something …}
Here interrupted() is a static method of the Thread class.• If the interrupted thread is executing a blocking operation like
wait() or sleep(), the operation will throw an InterruptedException. Interruptible threads should catch this exception and terminate themselves.
This mechanism depends on suitable implementation of the thread body. The programmer must decide at the outset whether it is important that a particular thread be responsive to interrupts—often it isn’t.
6868
Thread Groups There is a mechanism for organizing threads into
groups. This may be useful for imposing security restrictions on which threads can interrupt other threads, for example.
Check out the API of the ThreadGroup class if you think this may be important for your application.
6969
Thread-Local Variables An object from the ThreadLocal class stores an
object which has a different, local value in every thread.
Check the API of the ThreadLocal class for details.
7070
Volatile Variables Suppose a the value of a variable must be accessible by multiple
threads, but you decided you can’t afford the overheads of synchronized methods or the synchronized statement.• Presumably effects of race conditions are known to be innocuous.
Java does not guarantee—absent lock operations that force write-back to main memory—that the value of a variable written by a one thread will be visible to other threads.
But if you declare a field to be volatile: volatile int myVariable ;
the JVM is supposed to synchronize the value of any thread-local (cached) copy of the variable with central storage—making it visible to all threads—every time the variable is updated.
The exact semantics of volatile variables and the Java memory model in general is still controversial, see for example:“A New Approach to the Semantics of Multithreaded Java”,Jeremy Manson and William Pugh,http://www.cs.umd.edu/~pugh/java/memoryModel/
7171
Threads on Symmetric Multiprocessors
Most modern implementations of the Java Virtual Machine will map Java threads into native threads of the underlying operating system.• For example these may be POSIX threads.
On multiprocessor architectures with shared memory, these threads can exploit multiple available processors.
Hence it is possible to do true parallel programming using Java threads within a single JVM.
See the lectures on Java HPC, cited earlier, for examples.
7272
2) Network Programming in Java
7373
Contents of this Section Basics of network programming in Java
• Sockets background
• Socket classes, with simple HTTP examples
• Internet address classes
• URL classes Overview of New I/O extensions
• Efficient data transfer
• Non-blocking sockets
• Multiplexing (“select”) JSSE elements
7474
Sockets, Addresses and URLs
7575
Sockets Sockets first appeared in BSD UNIX (designed by
Bill Joy—later a designer of Java) circa 1982. Cross-protocol API for networking. Original
implementation supported protocols including:• TCP/IP
• Xerox NS
• Local UNIX inter-process communication. Today available in all variants of UNIX/Linux,
and in Windows through the WinSock API. Directly support a client/server architecture. Support connection-oriented protocols like TCP,
and connectionless protocols like UDP.
7676
BSD Socket Calls
NetworkClientServer
socket(): create socket
bind() : name socket
listen() :
accept(): accept connection
read() : get request
write(): send reply
socket() : create socketconnect():
write() : send request
read() : get reply
. . . process request . . .
7777
Port Numbers The bind() call on the server side establishes a
well-known address for the listening socket. In the case of an TCP/IP socket the important
part of this is the port number.• A port number is an integer between 0 and 64K.
• On any given host, only one server socket can be listening on a particular port at a particular time.
• In UNIX, port numbers below 1024 can only be used by a privileged user (the super-user). Any user can create a server socket listening on higher ports.
• Low port numbers are used by standard services, e.g.: 23 is the default port number for telnet 80 is the default port number for HTTP servers
7878
Making a Connection The client makes a connect() call, specifying the
remote host IP address, and the port number for the server socket it wants to connect to.• Meanwhile the server is waiting on an accept() call on the
server socket. When the connection is established, the accept() call
completes, returning a reference to a new socket.• Data is subsequently exchanged through the socket pair
consisting of the client socket, and the new socket on the server, returned by the accept() call.
7979
Sockets in Java Using sockets from C is traditionally quite hard. The
arguments of the BSD socket functions are complex.• Perhaps in part because of the historical need to support
multiple protocols. Luckily the API has been greatly simplified in the
Java binding for sockets. The associated classes are in the package java.net.
8080
Java Sockets from the Client Side A Java program can open a socket connection in one
step using a constructor of the Socket class: Socket t = new Socket(hostName, port) ;
Here hostName is a string, like “grid2004.org”, and port is an integer, like 80.• This constructor subsumes the socket() and connect()
calls in the BSD API. The Socket class has methods getInputStream() and
getOutputStream(), returning Java stream objects that swap data between the connected socket pair.• The connection is bi-directional: both client an server can
read and write.
8181
A Simple Clientimport java.io.* ;import java.net.* ;
public class TrivialBrowser {
public static void main(String [] args) throws IOException {
Socket s = new Socket(“www.grid2004.org”, 80) ;
PrintWriter out = new PrintWriter( new OutputStreamWriter(s.getOutputStream())) ; out.print("GET /spring2004/index.html HTTP/1.1\r\n") ; out.print("Host: www.grid2004.org\r\n\r\n") ; out.flush() ;
BufferedReader in = new BufferedReader( new InputStreamReader(s.getInputStream())) ; String line ; while((line = in.readLine()) != null) System.out.println(line) ; }}
8282
Remarks This implements a (drastically restricted) Web client. Cut and paste this slide, compile and run the code. It
prints out the HTML source for the course home page.• It connects to port 80 on the server (the HTTP port).
• It gets an output stream to write to the socket using getOuputStream().
• It sends an HTTP “GET” request on the stream, specifying the file it1spring01/index.html relative to the server’s document root.
• It gets an input stream to read from the socket using getInputStream().
• It copies lines from the socket connection to the console.
8383
Java Sockets from the Server Side The BSD operations socket(), bind() and listen() for a server-side
socket are subsumed in a constructor for the ServerSocket class:
ServerSocket s = new ServerSocket(port) ;
Here port is the integer port number, such as 80 (if you are writing a Web server), on which the server will listen.
Next the Java server will call the accept() method and wait for clients to connect to it. accept() returns an ordinary socket, completing the socket-pair for the connection:
Socket connection = s.accept() ; After processing the request, the client goes back to waiting on
accept(), for new client requests.• “Real” servers typically fork a thread or process to deal with the request,
and return immediately to waiting for the next client connection.
8484
A Simple Serverpublic static void main(String [] args) throws Exception { ServerSocket server = new ServerSocket(8080) ; while(true) { Socket sock = server.accept() ; BufferedReader in = new BufferedReader( new InputStreamReader(sock.getInputStream()) ; String header = in.readLine() ; . . . Skip over any other lines in request packet . . .
String fileName = … path component from 2nd field of header … ;
DataOutputStream out = new DataOutputStream(sock.getOutputStream()) ;
if( … file fileName exists… ) { byte [] bytes = … contents of local file fileName … ; out.writeBytes(“HTTP/1.0 200 OK\r\n”) ; out.writeBytes(“Content-Length: ” + bytes.length + “\r\n”) ; out.writeBytes(“Content-Type: text/html\r\n\r\n”) ; out.write(bytes) ; } else { … Send HTTP error status … } }}
8585
Remarks This implements a (drastically restricted) Web server.
• It creates a server socket listening to port 8080 on the local host.
• It gets a socket connection from a client using the accept() method, and then gets the input stream from the socket using getInputStream().
• We handle only “GET” requests; the second field will normally be the file name (preceded by “/”).
• It reads the file (assuming “.” as document root) and writes it to the output stream of the socket, in HTTP.
• A realistic server would probably spawn a new thread to deal with each transaction. The main loop would return immediately to waiting on accept().
8686
Other Features of java.net sockets The Socket and ServerSocket classes provide a bunch
of inquiry methods to determine the socket state. But there aren’t too many more operations one can
actually perform on sockets• One notable thing is setting a time out for I/O operations.
Notable things you can’t do include I/O in non-blocking mode, and any kind of select functionality.• These important features weren’t added until J2SE 1.4, in
the java.nio packages.
• In unaugmented java.net sockets, the closest you can come is to execute socket operations in dedicated threads.
8787
Internet Addresses The class java.net.InetAddress bundles together
various useful functions on Internet address• DNS lookup, reverse name resolution, etc.
Example methodsstatic InetAddress getByName(String host) {…}
static InetAddress getByAddress(byte [] addr) {…}
byte [] getAddress {…}
String getCanonicalHostName() {…}
static InetAddress getLocalHost() {…} InetAddress objects can be passed to the constructors
of socket classes.
8888
URL Objects Instead of explicitly opening a socket connection to
a Web server, a client can read information using the higher level URL class.
A constructor takes a URL string and creates a URL object:
URL url = new URL(“http://www.grids2004.org/spring2004/”) ;
• This constructor may throw a MalformedURLException.
This class is mostly (only?) useful for clients.
8989
Reading a File Using a URL Object Now if url is a URL object, the resource can be read by
opening a stream on the URL:
BufferedReader in =
new BufferedReader(
new InputStreamReader(url.openStream())) ;
This example creates a character stream that can be read like any other.
9090
URL Connection Objects A class java.net.URLConnection provides
additional functionality on URLs. A URLConnection is created by the openConnection() method:URLConnection connection = url.openConnection() ;
Methods on connection allow to return fields from the HTTP header: String getContentType() {…}
int getContentLength() {…}
. . . You can also open an InputStream or OutputStream
on a URL connection. The latter is used for HTTP “POST” requests.
9191
UDP in Java So far discussed use of Java sockets for TCP. The User Datagram Protocol is an alternative which is
neither connection-oriented nor “reliable”.• It transports datagrams: messages of fixed (limited) size.
• Messages may occasionally be lost; they may also be delivered out of order.
• But for applications that don’t need strong guarantees it can be faster than TCP, e.g. the Internet Domain Naming Service is implemented over UDP.
• Finally, you have to use UDP if you want to exploit IP multicast.
9292
A UDP Message Producerimport java.net.* ;
public class UDPProducer {
public static void main(String [] args) throws java.io.IOException {
DatagramSocket sock = new DatagramSocket() ;
InetAddress addr = InetAddress.getByName("grids.ucs.indiana.edu") ; int port = 3516 ;
for(int i = 0 ; i < 10 ; i++) { String message = "message " + i ;
byte [] data = message.getBytes() ;
DatagramPacket packet = new DatagramPacket(data, data.length, addr, port) ;
sock.send(packet) ; } }}
9393
A UDP Message Consumerimport java.net.* ;
public class UDPConsumer {
public static void main(String [] args) throws java.io.IOException { int port = 3516 ;
DatagramSocket sock = new DatagramSocket(port) ;
byte [] buffer = new byte [65536] ; while(true) {
DatagramPacket packet = new DatagramPacket(buffer, buffer.length) ;
sock.receive(packet) ;
String message = new String(packet.getData(), 0, packet.getLength()) ;
System.out.println(message) ; } }}
9494
Java “New I/O”
9595
NIO: New I/O Prior to the J2SE 1.4 release of Java, I/O had
become a performance bottleneck.• The old java.io stream classes had too many software
layers to be fast.• No way to multiplex data from multiple sources without
incurring thread context switches• No way to exploit modern OS tricks for high
performance I/O, like memory mapped files. New I/O changed that.
9696
Features of New I/O New I/O provides:
• A hierarchy of dedicated buffer classes that allow data to be moved from the JVM to the OS with minimal memory-to-memory copying, and without overheads like switching byte order—effectively give Java a “window” on system memory.
• A unified family of channel classes that allow data to be fed directly from buffers to files and sockets, without going through the slow old stream classes.
• Non-blocking I/O on sockets.• A family of classes to directly implement selection (or
readiness testing, or multiplexing) over a set of channels.• NIO also provides file locking for the first time in Java.
9797
References The Java NIO software is part of J2SE 1.4 and later,
fromhttp://java.sun.com/j2se/1.4
Online documentation is at:http://java.sun.com/j2se/1.4/nio
There is an authoritative book from O’Reilly:“Java NIO”, Ron Hitchens, 2002
9898
New I/O Buffers
9999
Buffers
A Buffer object is a container for a fixed amount of data.
It behaves something like a byte [] array, but is encapsulated so that the internal storage may be a block of system memory.• Adding data to, or getting it from, a buffer can be a very
direct way of getting information between a Java program and the underlying operating system.
All the I/O operations in New I/O operate on these buffer objects.
100100
The java.nio.Buffer Hierarchy
Buffer
CharBuffer IntBuffer DoubleBuffer ShortBuffer LongBuffer FloatBuffer ByteBuffer
MappedByteBuffer
101101
The ByteBuffer Class The most important buffer class in practice is the
ByteBuffer class. This represents a fixed-size vector of primitive bytes.
The storage used internally by the buffer class is called the backing store.
This backing store can either be an ordinary Java array, or a block of system memory.• If it is system memory, the buffer is called a direct buffer.
• Think of “system memory” as meaning something like a C array allocated by malloc(). It is not memory managed by the JVM, subject to garbage collection, etc.
102102
Creating Buffers There are various factory methods that can be used to
create a new ByteBuffer, including: ByteBuffer wrap(byte [] array)
ByteBuffer allocate(int capacity)
ByteBuffer allocateDirect(int capacity) These are all static methods of the ByteBuffer class:
• wrap() creates a ByteBuffer backed by the Java array provided by the caller.
• allocate() creates a ByteBuffer backed by an anonymous Java array, size capacity.
• allocateDirect() creates a direct ByteBuffer, backed by capacity bytes of system memory.
103103
Examplesimport java.nio.* ;
public class CreateBuffers { public static void main(String [] args) { int BUF_SIZE = 1024 ;
byte [] myBacking = new byte [BUF_SIZE] ;
ByteBuffer buffer1 = ByteBuffer.wrap(myBacking) ; // Uses array myBacking for storage.
ByteBuffer buffer2 = ByteBuffer.allocate(BUF_SIZE) ; // Uses buffer2.array() for storage.
ByteBuffer buffer3 = ByteBuffer.allocateDirect(BUF_SIZE) ; // Uses inaccessible system memory for storage. }}
104104
ByteBuffer Reads and Writes Has a family of put() and get() methods for writing and
reading the buffer, e.g.:
byte get() // Get the next byte in the bufferget(byte [] dst) // Get the next block of bytes
put(byte b) // Write b to the next position in bufferput(byte [] src) // Write block starting at next position
• I omitted the some of the return types to avoid confusion. These methods typically return a reference the original— possibly modified—buffer.
The put() and get() operations shown above are all relative operations: they get data from, or insert data into, the buffer, starting at the current position in the buffer.
105105
Relative Reads and Writes The position property works like the file pointer in sequential
file access (but don’t confuse it with a file pointer!)• The superclass Buffer has methods for explicitly setting the position
and related properties. There is also a limit property that has a confusing dual role:
• If you are reading a buffer, it should be the total amount of data previously written to the buffer.
• If you are writing to a buffer, it should normally be the capacity of the buffer.
Various operations implicitly work on the data between position and limit.
There are a also get() and put() methods that access bytes at absolute locations in the buffer, if you need them.
106106
Example: Writing and Reading
ByteBuffer buffer = ByteBuffer.allocateDirect(BUF_SIZE) ;
byte [] src = “hello world”.getBytes() ;buffer.put(src) ; // Write data to buffer
buffer.flip() ; // Prepare buffer for “draining”
byte [] dst = new byte [2048] ;buffer.get(dst, 0, buffer.limit()) ; // Read data from buffer
System.out.println(new String(dst, 0, buffer.limit())) ;
buffer.clear() ; // Empty buffer (optional here).
107107
Remarks After you finish writing to a buffer the flip() method can
be used to prepare the buffer for reading.• Technically, flip() sets limit to the current value of position, and
then sets position to zero.
You can use the get() variant: get(byte [] dst, int offset, int length)
to read less than dst.length bytes from the buffer.• Note offset is in the dst array, not the buffer!
You can clear() a buffer if you want to write to it again.• Technically, clear() sets position to zero, and sets limit to buffer’s
capacity.
108108
Other Primitive Types You can write other primitive types (char, int, double, etc)
to a ByteBuffer by methods like:
ByteBuffer putChar(char value) ByteBuffer putInt(int value) …
The putChar() method writes of the 2 bytes in a Java char, the putInt() methods write 4 bytes, etc.• There are corresponding getChar(), getInt(), … methods.• Take care: it is possible to write data as one type and read it as
another. Raises the question of what byte order the bytes of an int
(say) are written in.
109109
Endian-ness Can map a number (int, double, …) to a sequence of bytes,
with either most significant byte first (big-endian), or least significant byte first (little-endian).• Big-Endian: Sun Sparc, PowerPC, numeric fields in IP headers, …
• Little-Endian: Intel processors
In old java.io, numeric types always written big-endian. • I/O bottleneck if processor is little-endian.
In java.nio, the programmer specifies the byte order as a property of a ByteBuffer, by calling one of:
myBuffer.order(ByteOrder.BIG_ENDIAN)
myBuffer.order(ByteOrder.LITTLE_ENDIAN)
myBuffer.order(ByteOrder.nativeOrder())
• Latter ensures numeric data can be copied between buffer and JVM (which uses processor native order) without reformatting.
110110
View Buffers ByteBuffer has no methods for bulk transfer of arrays other
than type byte[]. Instead, create a view of (a portion of) a ByteBuffer as any
other kind of typed buffer, then use the bulk transfer methods on that view. Following methods of ByteBuffer create views:
CharBuffer asCharBuffer() IntBuffer asIntBuffer() …
To create a view of just a portion of a ByteBuffer, set position and limit appropriately beforehand—the created view only covers the region between these.
111111
Channels
112112
Channels A channel is a new abstraction in java.nio.
• In the package java.nio.channels. Channels are like high-level versions of the file-
descriptors in UNIX-like operating systems.• So a channel is a handle for performing I/O operations,
etc, on an open file or socket. Every java.nio channel has a peer java.io object,
one of: FileInputStream, FileOutputStream, RandomAccessFile, Socket, ServerSocket or DatagramSocket.• The traditional Java handle objects are still used—the
channel just provides extra NIO-specific functionality.
113113
Simplified Channel Hierarchy
Channel<<<Interface>>>
ByteChannel<<<interface>>> SelectableChannel
FileChannel SocketChannelDatagramChannel ServerSocketChannel
Some of the “inheritance” arcs here are indirect: we missedout some interesting intervening classes and interfaces.
114114
Opening A Channel
Socket channel classes have static factory methods called open(). One form takes a java.io.InetSocketAddress as argument.
File channels are not created directly; first create a java.io handle—one of FileInputStream, FileOutputStream, or RandomAccessFile—then use the new getChannel() method to get the peer channel.
115115
Examplesimport java.nio.* ; import java.nio.* ; import java.nio.* ;
public class CreateChannels { public static void main(String [] args) throws IOException {
InetSocketAddress addr = new InetSocketAddress("www.grid2004.org", 80) ; SocketChannel sc = SocketChannel.open(addr) ; // Create a socket channel.
RandomAccessFile raf = new RandomAccessFile("CreateChannels.class", "r") ; FileChannel fc = raf.getChannel() ; // Get a file channel. }}
116116
Using Channels Any channel that implements the ByteChannel
interface (namely all channels except ServerSocketChannel) provide a read() and a write() instance method:
int read(ByteBuffer dst) int write(ByteBuffer src)
• These may look reminiscent of the read() and write() system calls in UNIX:
int read(int fd, void* buf, int count) int write(int fd, void* buf, int count)
117117
Example: Sending an HTTP Request
int BUF_SIZE = 1024 ;ByteBuffer buffer = ByteBuffer.allocateDirect(BUF_SIZE) ;
InetSocketAddress addr = new InetSocketAddress("www.grid2004.org", 80) ;
SocketChannel sc = SocketChannel.open(addr) ;
String request = "GET /spring2004/index.html HTTP/1.1\r\n" + "Host: www.grid2004.org\r\n\r\n" ;
buffer.put(request.getBytes()) ;buffer.flip() ;
sc.write(buffer) ;buffer.clear() ;
118118
Example (cont.): Dump Response to a File
FileOutputStream fs = new FileOutputStream(“response.txt") ;
FileChannel fc = fs.getChannel() ;
while(sc.read(buffer) != -1) {
buffer.flip() ;
while(buffer.hasRemaining()) // position < limit fc.write(buffer) ;
buffer.clear() ;}
119119
Nonblocking Operations By calling the method
socket.configureBlocking(false) ;
you put a socket into nonblocking mode. In non-blocking mode:
• A read() operation only transfers data that is immediately available. If none, it returns 0.
• If data cannot be immediately written to a socket, a write() operation will immediately return 0.
• For a server socket, if no client is currently trying to connect, the accept() method immediately returns null.
• The connect() method is more complicated—negotiation with the server is always started. Should then poll channel until finishConnect() returns true.
120120
Interruptible Operations The standard channels in NIO are all interruptible. If a thread is blocked waiting on a channel, and the
thread’s interrupt() method is called, the channel will be closed, and the thread will be woken and sent a ClosedByInterruptException.• To avoid race conditions, the same will happen if an
operation on a channel is attempted by a thread whose interrupt status is already true.
• See the lecture on threads for a discussion of interrupts. This represents progress over traditional Java I/O,
where interruption of blocking operations was not guaranteed.
121121
Other Features of Channels File channels provide a quite general file locking
facility, but we don’t have space to discuss it here. There is a special channel implementation
representing a kind of pipe, which can be used for inter-thread communication.
122122
Selectors
123123
Readiness Selection Prior to New I/O, Java provided no standard way of
selecting from a set of possible socket operations just the ones that are currently ready to proceed.• Previously one could achieve similar effects in Java by doing
blocking I/O operations in separate threads, then merging the results through Java thread synchronization. But this can be inefficient because thread context switching and synchronization is quite slow.
One way of achieving the desired effect in New I/O would be set all the channels involved to non-blocking mode, and use a polling loop to wait until some are ready to proceed (“busy-waiting”).
A more structured—and potentially more efficient—approach is to use Selectors.• This corresponds to using the select() system call in many flavors of
UNIX.
124124
Classes Involved in Selection Selection can be done on any channel extending
SelectableChannel—out of the standard channels, this means the three kinds of socket channel.
The class that supports the select() operation itself is Selector. This is a sort of container class for the set of channels in which we are interested.
The last class involved is SelectionKey, which is said to represent the binding between a channel and a selector.• In some sense it is part of the internal representation of the
Selector, but the NIO designers decided to make it an explicit part of the API.
125125
Setting Up Selectors Create a selector by the open() factory method. This is a static
method of the Selector class. A channel is added to a selector by calling the method:
SelectionKey register(Selector sel, int ops)
• This (slightly oddly) is an instance method of the SelectableChannel class (rather than an operation on Selector).
• Here ops is a bit-set representing the interest set for this channel. Created by oring together one or more of:
SelectionKey.OP_READ SelectionKey.OP_WRITE SelectionKey.OP_CONNECT SelectionKey.OP_ACCEPT
• A channel added to a selector must be in nonblocking mode! The returned SelectionKey created gets stored in the Selector; in
simple cases you don’t need to save it yourself.
126126
Example Here we create a selector, and register three pre-
existing channels to the selector:
Selector selector = Selector.open() ;
channel1.register (selector, SelectionKey.OP_READ) ;channel2.register (selector, SelectionKey.OP_WRITE) ;channel3.register (selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE) ;
For channel1 the interest set is reads only, for channel2 it is writes only, for channel3 it is reads and writes.
Note all channels must be in non-blocking mode.
127127
select() and the Selected Key Set To inspect the set of channels, to see what operations are
newly ready to proceed, you call the select() method on the selector.• This call affects a set of selected keys embedded in the selector.
To use selectors, you must understand that a selector maintains a Set object representing this selected keys set.• Because each key is associated with a channel, this is equivalent to a
set of selected channels.• The set of selected keys is different from (normally a subset of) the
registered key set.• Each time the select() method is called it may add new keys to the
selected key set, as operations become ready to proceed.• You, as the programmer, are responsible for explicitly removing keys
from the selected key set inside the selector, as you deal with operations that have become ready.
128128
Ready Sets There is one more complication. We saw that each key in the registered key set has an
associated interest set, which is a subset of the 4 possible operations on sockets.
Similarly each key in the selected key set has an associated ready set, which is a subset of the interest set—representing the actual operations that have been found ready to proceed.
Besides adding new keys to the selected key set, a select() operation may add new operations to the ready set of a key already in the selected key set.
To probe the ready set of a SelectionKey you can use : isReadable() isWriteable() isConnectable() isAcceptable()
129129
A Pattern for Using select()… register some channels with selector …
while(true) { selector.select() ;
Iterator it = selector.selectedKeys().iterator() ;
while( it.hasNext() ) { SelectionKey key = it.next() ;
if( key.isReadable() ) … perform read() operation on key.channel() … if( key.isWriteable() ) … perform write() operation on key.channel() … if( key.isConnectable() ) … perform connect() operation on key.channel() … if( key.isAcceptable() ) … perform accept() operation on key.channel() …
it.remove() ; } }
130130
Remarks More generally, the code that handles a ready
operation may also alter the set of channels registered with the selector• e.g. after doing an accept() you may want to register
the returned SocketChannel with the selector, to wait for read() or write() operations.
In most cases only a subset of the possible operations read, write, accept, connect are in interest sets of keys you registered, so you won’t need all 4 tests.
131131
Key Attachments One problem is that when it.next() returns a key,
there is no convenient way to know which registered channel it corresponds to.
You can specify an arbitrary object as an attachment to the key when you create it; later when you get the key from the selected set, you can extract the attachment, and use its content to decide which channel this is and how to treat it.• At its most basic the attachment might just be an Integer
index identifying the channel.
132132
New I/O Conclusion We briefly visited several topics in New I/O. New I/O has been widely hailed as an important
step forward in getting serious performance out of the Java platform.
Besides raw performance, it provides the most critical I/O and networking functionalities that were absent in earlier versions of Java.