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

dbcarpen@indiana.edugcf@indiana.edu

mpierce@cs.indiana.edu 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.