A typical wedding photo was affixed to door lift doors in a law firm. Unfortunately, every time the doors opened, the couple split up. But help was at hand for everyone in the same position as soon as they stepped into the lift: a sign showed the name of the law firm and which floor the office was on.
| Command | Description | Example |
|---|---|---|
| get | Reads a value | get mykey |
| set | Set a key unconditionally | set mykey 0 60 5 |
| add | Add a new key | add newkey 0 60 5 |
| replace | Overwrite existing key | replace key 0 60 5 |
| append | Append data to existing key | append key 0 60 15 |
| prepend | Prepend data to existing key | prepend key 0 60 15 |
| incr | Increments numerical key value by given number | incr mykey 2 |
| decr | Decrements numerical key value by given number | decr mykey 5 |
| delete | Deletes an existing key | delete mykey |
| flush_all | Invalidate specific items immediately | flush_all |
| Invalidate all items in n seconds | flush_all 900 | |
| stats | Prints general statistics | stats |
| Prints memory statistics | stats slabs | |
| Prints memory statistics | stats malloc | |
| Print higher level allocation statistics | stats items | |
| stats detail | ||
| stats sizes | ||
| Resets statistics | stats reset | |
| version | Prints server version. | version |
| verbosity | Increases log level | verbosity |
| quit | Terminate telnet session | quit |
Over the years, we have watched great tennis players who have played some beautiful tennis. But they have also given us great replies and one-liners. So, here we take a look at that.
Andy Roddick will definitely contribute to the list. Go A-Rod.
Hilarious Questions and Replies
After Wimbledon win, Roger Federer had this conversation with an interviewer:
Interviewer: 'After you had won Wimbledon, you were given a cow called Juliette when you returned to Switzerland. Is there another Juliette waiting for you?'
Federer: 'I hope not. By the way, Juliette is expecting a calf.'
Interviewer: 'Congratulations!'
Federer: 'Thanks, but I’m not the father.'
Before US open '05, Roddick was asked:
Interviewer: 'What are your chances in the US Open?
Roddick: 'As good as anybody not named Roger.'
Another Roddick gem:
Interviewer: 'You have a very fast serve.'
Roddick: 'It killed a small dog.'
After which comment, he claimed he was joking because she was not laughing at all...
Roddick: 'I'm joking, I am joking...The dog was huge.'
The press conference he did after losing to Roger in the Aussie '07 SF...had some interesting transcriptions...
Reporter: 'What was it like for you being on the end of that?'
Andy: 'It was frustrating. It was miserable. It sucked. It was terrible. Besides that it was fine.'
Reporter: 'What did Jimmy (Connors—his coach) say after?'
Andy: 'He gave me a beer.'
Reporter: 'Take us from 4-4, because up 'til then you were in the match. Then you got broken.'
Andy: 'Then I broken three more times. And two more times in the third set, and it was over 26 minutes later. Is that about what you saw too?'
Reporter: 'How do you rate Haas's or Gonzalez's chances in the final?'
Andy: 'Slim.'
Reporter: 'You're performance on here is better than on court.'
Andy: 'No shit. If there were rankings for press conferences I wouldn't have to worry about falling out of the top five I hope.'
Reporter: 'After a defeat like this do you sleep well?'
Andy: 'Depends how much I drink tonight.'
Reporter: 'How much would you have paid in order to not have to come to the press conference tonight?'
Andy: 'That's about the best question that's been asked. Well, I can't really say an amount because I would have gotten fined $20,000 (for not coming to the press conference). So, it would have to be less than that, right? If we're thinking logically. But it wouldn't be about the money. It would be about running away and not facing it. I would pay a lot of money if people would make stuff up and pretend I said it. But my dad didn't raise me like that, so here I am.'
The last one of his replies; Roddick was invited to some show, and the conversation with the host was like this:
Host: 'Do you have any hint for me? Did you bring me present of any sort?'
Roddick: 'A present?'
Host: 'Yeah'
Roddick: 'It's compulsory?'
Host: 'Ya, Great Agassi came to the show, and he gave me the racket he won the Davis Cup with.'
Roddick: 'Really!!'
Host: 'You didn't bring me anything?'
Roddick: 'I CAN'T BRING YOU SHIT...'
Reporter: 'What did Jimmy say? US Open he got on a real roll too. Did you talk about what to do if Roger got on a roll, change strategy, slow it down?'
Andy: 'There's a lot of strategy talk. But not if you're down 6-4 6-0 2-0. We didn't really talk about that. Oops.'
One-Liners
Now, some good one-liners:
'It's just unreal, I'm shocked myself. I've played good matches here, but never really almost destroyed somebody. It's a match for him to forget...and for me to remember!'
—Roger Federer, after defeating Andy Roddick in the AO '07 SF
'Hey—you guys with the ladder. If you come here I'll buy you pizza.'
—Andy Roddick, calling out to firefighters in the process of rescuing Roddick and other hotel guests from a fire in Rome.
'I've got to feel good because (Djokovic) has got about 16 injuries'
—Andy Roddick on Djovokic's injuries.
Roddick: 'Isn't it both of them? And a back? and a hip? And a cramp... bird flu... anthrax. SARS, common cough, and a cold.'
'My hobbies include underwater fire extinguishing.'
—Andy Roddick
“If Pete’s child is a girl, my son will like her; if he’s a boy, my son will defeat him.” —Agassi.
Asked what it feels like to be the World No. 1, Roger jokingly replied:
'It's great. Everybody suddenly rates my good strokes as outstanding, and my poorer strokes as almost outstanding.'
'When I was 40, my doctor advised me that a man in his 40s shouldn't play tennis. I heeded his advice carefully and could hardly wait until I reached 50 to start again.'
—Hugo L. Black
'I did my job, got a beautiful cup and a beautiful cheque. That’s it. I didn’t change the world'
—Marat on his Slam wins
“Yeah, I choked, but shit happens”
—Marat Safin
'I'd like just one time to see you guys step up and do something for us.'
—Andy Roddick venting on ATP Supervisor Gayle Bradshaw after getting no love from the chair umpire at the ATP Scottsdale event.
'I don't go out there to love my enemy. I go out there to squash him.' —Jimmy Connors
'I am the best tennis player who cannot play tennis.' —Ion Tiriac
'Winners aren't popular, losers often are.' —Virginia Wade
'If you put two monkeys on to play you'd still pack the centre court.' —Neil Fraser, commenting on Wimbledon's popularity
'One day when a linesman starts to laugh, I swear I will hit the guy over the head with my racket. I think it will be the end of my career, but I will be happy.' —Ilie Nastase
'When I won Wimbledon, I said to God: Just let me win this one tournament and I won't play another match. Maybe God's telling me to go home, but I don't want to go home. We are negotiating at the moment.' —Goran Ivanisevic
'If I can't serve on grass, I can maybe help cut the grass, paint the lines, and serve some strawberries.' —Goran Ivanisevic
'The best doubles pair in the world is John McEnroe and anyone else.' —Peter Fleming
'I can't believe he is dumping me, his buddy for seven years, for a kid he's never seen before.' —Paul Haarhuis complaining about his doubles partner Jacco Eltingh flying home from the US Open for the birth of his son
'How to shake hands.' —Bettina Bunge, on what she had learned from a series of rapid defeats to Martina Navratilova
'Experience is a great advantage. The problem is that when you get the experience, you're too damned old to do anything about it.' —Jimmy Connors
'I love Wimbledon. But why don't they stage it in the summer?' —Vijay Amritraj during the rain-drenched 2007 Championships)
'If you want to talk, it's okay with me. I sit and relax.' —Gael Monfils taking a seat while Nicolas Almagro debated with umpire and match referee, Australian Open 2009
'I'm gonna have to start winning some of the matches to call it a rivalry!' —Andy Roddick on being asked whether he and Roger Federer had a rivalry that would last for years
'Pete is a step and a half slower.' —Greg Rusedski after losing to Pete Sampras in the US Open)
'Against him I don't need to be a step and a half quicker.' —Pete Sampras responding to Greg Rusedski's criticism—he went on to win the title!
'Umpiring, the only job in the world where you can screw up on a daily basis and still have one!' —Andy Roddick
'She doesn't sleep. At night she seems to turn into a vampire.' —Goran Ivanisevic on the joys of fatherhood
'Look, Nastase, we used to have a famous cricket match in this country called Gentlemen versus Players. The Gentlemen were put down on the scorecard as 'Mister' because they were gentlemen. By no stretch of the imagination can anybody call you a gentleman.' —Wimbledon umpire, on being told to address Ilie Nastase as 'Mister'
'Thanks, but no. I want to be a winner.' —Maria Sharapova on being compared to Anna Kournikova
'Going to the dentist. On second thought, I would rather have a root canal than play Santoro.' —Marat Safin, on being asked his biggest fear
'If I don't win tonight, I guess the sun will still come up in the morning.' —Arthur Ashe
'I had a feeling today that Venus Williams would either win or lose.' —Martina Navratilova
'The difference between night and day is, er, night and day.' —Tim Henman
Andrew Castle: 'Where are all these Serbians from?'
Greg Rudseski: 'Serbia?' (during Wimbledon 2007)
'There are no excuses. I could blame it on a lack of match practice time, or on playing the world No. 10...I had a sore stomach as well.' —Sania Mirza, Australian Open 2009
'I broke all my rackets. I didn't have a racket for the fifth set. I broke four. Now, I hold the record. Now, I go home. No rackets. I really don't like these rackets.' —Nikolay Davydenko, US Open 2008
'You're on live TV, you know. You look like a real moron right now.'
—The lovable Andy Roddick, yelling at a chair umpire at Indianapolis
'You're an idiot! Stay in school kids, or you'll end up being an umpire.'
Tornado is a relatively simple, non-blocking Web server framework written in Python, designed to handle thousands of simultaneous connections, making it ideal for real-time Web services.Three key parts of Tornado:
While Tornado is similar to existing Web-frameworks in Python (Django, Google’s webapp, web.py), it focuses on speed and handling large amounts of simultaneous traffic.
All the basic site building blocks – Tornado comes with built-in support for a lot of the most difficult and tedious aspects of web development, including templates, signed cookies, user authentication, localization, aggressive static file caching, cross-site request forgery protection, and third party authentication like Facebook Connect. You only need to use the features you want, and it is easy to mix and match Tornado with other frameworks.
Real-time services – Tornado supports large numbers of concurrent connections. It is easy to write real-time services via long polling or HTTP streaming with Tornado. Every active user of FriendFeed maintains an open connection to FriendFeed’s servers.
High performance – Tornado is pretty fast relative to most Python web frameworks. Tornado’s baseline throughput was over four times higher than the other frameworks.
here
java.nio.* -- allow Java applications to handle thousands of open connections while delivering scalability and excellent performance. These packages introduce four key abstractions that work together to solve the problems of traditional Java I/O: Buffer contains data in a linear sequence for reading or writing. A special buffer provides for memory-mapped file I/O. charset maps Unicode character strings to and from byte sequences. (Yes, this is Java's third shot at character conversion.) Channels -- which can be sockets, files, or pipes -- represent a bidirectional communication pipe. Selectors multiplex asynchronous I/O operations into one or more threads. ServerSocket, accept incoming connections, and service each connection. Assume for this example that servicing a connection involves reading a request and sending a response. That resembles the way a Web server works. Figure 1 depicts the server's lifecycle. At each heavy black line, the I/O operation blocks -- that is, the operation call won't return until the operation completes. 
ServerSocket is easy: ServerSocket server = new ServerSocket(8001);
Socket newConnection = server.accept();
server.accept() blocks until the ServerSocket accepts an incoming network connection. That leaves the calling thread sitting for an indeterminate length of time. If this application has only one thread, it does a great impression of a system hang. Request object. It is a fiction invented to keep this example simple. InputStream in = newConnection.getInputStream();
InputStreamReader reader = new InputStreamReader(in);
LineNumberReader lnr = new LineNumberReader(reader);
Request request = new Request();
while(!request.isComplete()) {
String line = lnr.readLine();
request.addLine(line);
}
lnr.readLine() eventually filters down to call SocketInputStream.read(). There, if data waits in the network buffer, the call immediately returns some data to the caller. If there isn't enough data buffered, then the call to read blocks until enough data is received or the other computer closes the socket. Because LineNumberReader asks for data in chunks (it extends BufferedReader), it might just sit around waiting to fill a buffer, even though the request is actually complete. The tail end of the request can sit in a buffer that LineNumberReader has not returned. LineNumberReader creates a buffer to hold the data it reads from the socket, but it also creates Strings to hold the same data. In fact, internally, it creates a StringBuffer. LineNumberReader reuses its own buffer, which helps a little. Nevertheless, all the Strings quickly become garbage. Response object creates its stream by locating and opening a file): Response response = request.generateResponse();
OutputStream out = newConnection.getOutputStream();
InputStream in = response.getInputStream();
int ch;
while(-1 != (ch = in.read())) {
out.write(ch);
}
newConnection.close();
Strings). The new I/O avoids this waste by using Buffers to read and write data. A Buffer is a linear, sequential dataset and holds only one data type according to its class: | java.nio.Buffer | Abstract base class |
java.nio.ByteBuffer | Holds bytes. Can be direct or nondirect. Can be read from a ReadableByteChannel. Can be written to a WritableByteChannel. |
java.nio.MappedByteBuffer | Holds bytes. Always direct. Contents are a memory-mapped region of a file. |
java.nio.CharBuffer | Holds chars. Cannot be written to a Channel. |
java.nio.DoubleBuffer | Holds doubles. Cannot be written to a Channel. |
java.nio.FloatBuffer | Holds floats. Can be direct or nondirect. |
java.nio.IntBuffer | Holds ints. Can be direct or nondirect. |
java.nio.LongBuffer | Holds longs. Can be direct or nondirect. |
java.nio.ShortBuffer | Holds shorts. Can be direct or nondirect. |
allocate(int capacity) or allocateDirect(int capacity) on a concrete subclass. As a special case, you can create a MappedByteBuffer by calling FileChannel.map(int mode, long position, int size). ByteBuffer.wrap(byte[])) -- to construct a Buffer on top of a Java array, for example. Buffer, you fix its capacity; you can't resize these containers. Capacity refers to the number of primitive elements the Buffer can contain. Although you can put multibyte data types (short, int, float, long, and so on) into a ByteBuffer, its capacity is still measured in bytes. The ByteBuffer converts larger data types into byte sequences when you put them into the buffer. (See the next section for a discussion about byte ordering.) Figure 3 shows a brand new ByteBuffer created by the code below. The buffer features a capacity of eight bytes. ByteBuffer example = ByteBuffer.allocateDirect(8);
Buffer's position is the index of the next element that will be written or read. As you can see in Figure 3, position starts at zero for a newly allocated Buffer. As you put data into the Buffer, position climbs toward the limit. Figure 4 shows the same buffer after the calls in the next code fragment add some data. example.put( (byte)0xca ); example.putShort( (short)0xfeba ); example.put( (byte)0xbe );
put() past the limit causes a BufferOverflowException. Similarly, attempting to get() past the limit causes a BufferUnderflowException. For a new buffer, the limit equals the capacity. There is a trick to using buffers. Between filling the buffer with data and writing it on a Channel, the buffer must flip. Flipping a buffer primes it for a new sequence of operations. If you've been putting data into a buffer, flipping it ensures that it's ready to read the data. More precisely, flipping the buffer sets its limit to the current position and then resets its position to zero. Its capacity does not change. The following code flips the buffer. Figure 5 depicts the effect of flipping the sample buffer. example.flip();
get() returns four bytes before it throws a BufferUnderflowException. 
example.putShort() illustrated in Figure 4 resulted in 0xFE at Position 1 and 0xBA at Position 2. In other words, the most significant byte went into the lowest numbered slot. Therefore, Figure 4 offers an example of big-endian byte ordering. java.nio.ByteBuffer defaults to big-endian byte ordering on all machines, no matter what the underlying CPU might use. (In fact, Intel microprocessors are little endian.) ByteBuffer uses instances of java.nio.ByteOrder to determine its byte ordering. The static constants ByteOrder.BIG_ENDIAN and ByteOrder.LITTLE_ENDIAN do exactly what you would expect. Buffers to avoid allocations during request processing. Or you could create Buffers for common situations and keep them around. The following fragment from our sample HTTP server illustrates the latter approach: class ReadWriteThread extends Thread {
...
private WeakHashMap fileCache = new WeakHashMap();
private ByteBuffer[] responseBuffers = new ByteBuffer[2];
...
public ReadWriteThread(Selector readSelector,
ConnectionList acceptedConnections,
File dir)
throws Exception
{
super("Reader-Writer");
...
responseBuffers[0] = initializeResponseHeader();
...
}
...
protected ByteBuffer initializeResponseHeader() throws Exception {
// Pre-load a "good" HTTP response as characters.
CharBuffer chars = CharBuffer.allocate(88);
chars.put("HTTP/1.1 200 OK\n");
chars.put("Connection: close\n");
chars.put("Server: Java New I/O Example\n");
chars.put("Content-Type: text/html\n");
chars.put("\n");
chars.flip();
// Translate the Unicode characters into ASCII bytes.
ByteBuffer buffer = ascii.newEncoder().encode(chars);
ByteBuffer directBuffer = ByteBuffer.allocateDirect(buffer.limit());
directBuffer.put(buffer);
return directBuffer;
}
...
}
ByteBuffers for the responses. The first buffer always contains the HTTP response header. This particular server always sends the same headers and the same response code. To send error responses, the method sendError() (not shown above) creates a similar buffer with an HTTP error response for a particular status code. It saves the error response headers in a WeakHashMap, keyed by the HTTP status code. initializeResponseHeader() method actually uses three buffers. It fills a CharBuffer with Strings. The character set encoder turns the Unicode strings into bytes. I will cover character conversion later. Since this header is sent at the beginning of every response from the server, it saves time to create the response once, save it in a buffer, and just send the buffer every time. Notice the call to flip the CharBuffer after we put our data into it. The third buffer used in initializeResponseHeader() seems a bit odd. Why convert the characters into a ByteBuffer just to then copy them into another ByteBuffer? The answer: because CharsetEncoder creates a nondirect ByteBuffer. When you write a direct buffer to a channel, it immediately passes to native calls. However, when you pass a nondirect buffer to a channel, the channel provider creates a new, direct buffer and copies the nondirect buffer's contents. That means extra garbage and a data copy. It worsens when the buffer with the response header is sent in every HTTP response. Why let the channel provider create a direct buffer on every request if we can do it once and get it over with? ByteBuffers, two related problems crop up: byte ordering and character conversion. ByteBuffer handles byte ordering internally using the ByteOrder class. It does not deal with character conversion, however. In fact, ByteBuffer doesn't even have methods for reading or writing strings. Character conversion is a complicated topic, subject to many international standards, including the Internet Engineering Task Force's requests for comments, the Unicode Standard, and the Internet Assigned Numbers Authority (IANA). However, almost every time you deal with character conversion, you must convert Unicode strings to either ASCII or UTF-8. Fortunately, these are easy cases to handle. ASCII and UTF-8 are examples of character sets. A character set defines a mapping from Unicode to bytes and back again. Character sets are named according to IANA standards. In Java, a character set is represented by an instance of java.nio.charset.Charset. As with most internationalization classes, you do not construct Charsets directly. Instead, you use the static factory method Charset.forName() to acquire an appropriate instance. Charset.availableCharsets() gives you a map of supported character set names and their Charset instances. The J2SE 1.4 beta includes eight character sets: US-ASCII, ISO-8859-1, ISO-8859-15, UTF-8, UTF-16, UTF-16BE (big endian), UTF-16LE (little endian), and Windows-1252.Charset constructs CharsetEncoders and CharsetDecoders to convert character sequences into bytes and back again. Take another look at ReadWriteThread below. The encoder shows up twice for converting an entire CharBuffer into a ByteBuffer. readRequest, on the other hand, uses the decoder on the incoming request. class ReadWriteThread extends Thread {
...
private Charset ascii;
...
public ReadWriteThread(Selector readSelector,
ConnectionList acceptedConnections,
File dir)
throws Exception
{
super("Reader-Writer");
...
ascii = Charset.forName("US-ASCII");
responseBuffers[0] = initializeResponseHeader();
...
}
...
protected ByteBuffer initializeResponseHeader() throws Exception {
...
// Translate the Unicode characters into ASCII bytes.
ByteBuffer buffer = ascii.newEncoder().encode(chars);
...
}
...
protected String readRequest(SelectionKey key) throws Exception {
SocketChannel incomingChannel = (SocketChannel)key.channel();
Socket incomingSocket = incomingChannel.socket();
...
int bytesRead = incomingChannel.read(readBuffer);
readBuffer.flip();
String result = asciiDecoder.decode(readBuffer).toString();
readBuffer.clear();
StringBuffer requestString = (StringBuffer)key.attachment();
requestString.append(result);
...
}
...
protected void sendError(SocketChannel channel,
RequestException error) throws Exception {
...
// Translate the Unicode characters into ASCII bytes.
buffer = ascii.newEncoder().encode(chars);
errorBufferCache.put(error, buffer);
...
}
}
java.io classes know how to read or write Buffers. In Merlin, Channels read data into Buffers and send data from Buffers. Channels join Streams and Readers as a key I/O construct. A channel might be thought of as a connection to some device, program, or network. At the top level, the java.nio.channels.Channel interface just knows whether it is open or closed. A nifty feature of Channel is that one thread can be blocked on an operation, and another thread can close the channel. When the channel closes, the blocked thread awakens with an exception indicating that the channel closed. There are several Channel classes, as shown in Figure 9. 
java.nio.channels.ReadableByteChannel), writing (java.nio.channels.WritableByteChannel), and scatter/gather operations. A gathering write can write data from several buffers to the channel in one contiguous operation. Conversely, a scattering read can read data from the channel and deposit it into several buffers, filling each one in turn to its limit. Scatter/gather operations have been used for years in high-performance I/O managers in Unix and Windows NT. SCSI controllers also employ scatter/gather to improve overall performance. In Java, the channels quickly pass scatter/gather operations down to the native operating system functions for vectored I/O. Scatter/gather operations also ease protocol or file handling, particularly when you create fixed headers in some buffers and change only one or two variable data buffers. You can configure channels for blocking or nonblocking operations. When blocking, calls to read, write, or other operations do not return until the operation completes. Large writes over a slow socket can take a long time. In nonblocking mode, a call to write a large buffer over a slow socket would just queue up the data (probably in an operating system buffer, though it could even queue it up in a buffer on the network card) and return immediately. The thread can move on to other tasks while the operating system's I/O manager finishes the job. Similarly, the operating system always buffers incoming data until the application asks for it. When blocking, if the application asks for more data than the operating system has received, the call blocks until more data comes in. In nonblocking mode, the application just gets whatever data is immediately available. The sample code included with this article uses each of the following three channels at various times: ServerSocketChannelSocketChannelFileChanneljava.nio.channels.ServerSocketChannel plays the same role as java.net.ServerSocket. It creates a listening socket that accepts incoming connections. It cannot read or write. ServerSocketChannel.socket() provides access to the underlying ServerSocket, so you can still set socket options that way. As is the case with all the specific channels, you do not construct ServerSocketChannel instances directly. Instead, use the ServerSocketChannel.open() factory method. ServerSocketChannel.accept() returns a java.nio.channel.SocketChannel for a newly connected client. (Note: Before Beta 3, accept() returned a java.net.Socket. Now the method returns a SocketChannel, which is less confusing for developers.) If the ServerSocketChannel is in blocking mode, accept() won't return until a connection request arrives. (There is an exception: you can set a socket timeout on the ServerSocket. In that case, accept() eventually throws a TimeoutException.) If the ServerSocketChannel is in nonblocking mode, accept() always returns immediately with either a Socket or null. In the sample code, AcceptThread constructs a ServerSocketChannel called ssc and binds it to a local TCP port: class AcceptThread extends Thread {
private ServerSocketChannel ssc;
public AcceptThread(Selector connectSelector,
ConnectionList list,
int port)
throws Exception
{
super("Acceptor");
...
ssc = ServerSocketChannel.open();
ssc.configureBlocking(false);
InetSocketAddress address = new InetSocketAddress(port);
ssc.socket().bind(address);
...
}
java.nio.channels.SocketChannel is the real workhorse in this application. It encapsulates a java.net.Socket and adds a nonblocking mode and a state machine. SocketChannels can be created one of two ways. First, SocketChannel.open() creates a new, unconnected SocketChannel. Second, the Socket returned by ServerSocketChannel.accept() actually has an open and connected SocketChannel attached to it. This code fragment, from AcceptThread, illustrates the second approach to acquiring a SocketChannel: class AcceptThread extends Thread {
private ConnectionList acceptedConnections;
...
protected void acceptPendingConnections() throws Exception {
...
for(Iterator i = readyKeys.iterator(); i.hasNext(); ) {
...
ServerSocketChannel readyChannel = (ServerSocketChannel)key.channel();
SocketChannel incomingChannel = readyChannel.accept();
acceptedConnections.push(incomingChannel);
}
}
}
SelectableChannel's other subclasses, SocketChannel can be blocking or nonblocking. If it is blocking, then read and write operations on the SocketChannel behave exactly like blocking reads and writes on a Socket, with one vital exception: these blocking reads and writes can be interrupted if another thread closes the channel. SocketChannel and ServerSocketChannel, java.nio.channels.FileChannel does not derive from SelectableChannel. As you will see in the next section, that means that FileChannels cannot be used for nonblocking I/O. Nevertheless, FileChannel has a slew of sophisticated features that were previously reserved for C programmers. FileChannels allow locking of file portions and direct file-to-file transfers that use the operating system's file cache. FileChannel can also map file regions into memory. Memory mapping a file uses the native operating system's memory manager to make a file's contents look like memory locations. For more efficient mapping, the operating system uses its disk paging system. From the application's perspective, the file contents just exist in memory at some range of addresses. When it maps a file region into memory, FileChannel creates a MappedByteBuffer to represent that memory region. MappedByteBuffer is a type of direct byte buffer. A MappedByteBuffer offers two big advantages. First, reading memory-mapped files is fast. The biggest gains go to sequential access, but random access also speeds up. The operating system can page the file into memory far better than java.io.BufferedInputStream can do its block reads. The second advantage is that using MappedByteBuffers to send files is simple, as shown in the next code fragment, also from ReadWriteThread: protected void sendFile(String uri, SocketChannel channel) throws
RequestException, IOException {
if(Server.verbose)
System.out.println("ReadWriteThread: Sending " + uri);
Object obj = fileCache.get(uri);
if(obj == null) {
Server.statistics.fileMiss();
try {
File f = new File(baseDirectory, uri);
FileInputStream fis = new FileInputStream(f);
FileChannel fc = fis.getChannel();
int fileSize = (int)fc.size();
responseBuffers[1] = fc.map(FileChannel.MapMode.READ_ONLY, 0, fileSize);
fileCache.put(uri, responseBuffers[1]);
} catch(FileNotFoundException fnfe) {
throw RequestException.PAGE_NOT_FOUND;
}
} else {
Server.statistics.fileHit();
responseBuffers[1] = (MappedByteBuffer)obj;
responseBuffers[1].rewind();
}
responseBuffers[0].rewind();
channel.write(responseBuffers);
}
sendFile() method sends a file as an HTTP response. The lines inside the try block create the MappedByteBuffer. The rest of the method caches the memory-mapped file buffers in a WeakHashMap. That way, repeated requests for the same file are blindingly fast, yet when memory tightens, the garbage collector eliminates the cached files. You could keep the buffers in a normal HashMap, but only if you know that the file number is small (and fixed). Notice that the call to channel.write() actually passes an array of two ByteBuffers (one direct, one mapped). Passing two buffers makes the call a gathering write operation. The first buffer is fixed to contain the HTTP response code, headers, and body separator. The second buffer is the memory-mapped file. The channel sends the entire contents of the first buffer (the response header) followed by the entire contents of the second buffer (the file data). java.nio.channels.Channels. Channels allows new I/O channels to interoperate with old I/O streams and readers. Channels has static methods that can create a channel from a stream or reader or vice versa. It proves most useful when you deal with third-party packages that expect streams, such as XML parsers. Selectors serve that purpose. java.nio.channels.Selector plays the role of a Reactor. A Selector multiplexes events on SelectableChannels. In other words, a Selector provides a rendezvous point between I/O events on channels and client applications. Each SelectableChannel can register interest in certain events. Instead of notifying the application when the events happen, the channels track the events. Later, when the application calls one of the selection methods on the Selector, it polls the registered channels to see if any interesting events have occurred. Figure 10 depicts an example of a selector with two registered channels. 
SelectionKey defines all possible operation bits, which are used twice. First, when the application registers the channel by calling SelectableChannel.register(Selector sel, int operations), it passes the sum of the desired operations as the second argument. Then, once a SelectionKey has been selected, the SelectionKey's readyOps() method returns the sum of all the operation bits that its channel is ready to perform. SelectableChannel.validOps() returns the allowed operations for each channel. Attempting to register a channel for operations it doesn't support results in an IllegalArgumentException. The following table lists the valid operations for each concrete subclass of SelectableChannel: ServerSocketChannel | OP_ACCEPT |
SocketChannel | OP_CONNECT, OP_READ, OP_WRITE |
DatagramChannel | OP_READ, OP_WRITE |
Pipe.SourceChannel | OP_READ |
Pipe.SinkChannel | OP_WRITE |
SelectionKey.cancel(), by closing the key's channel, or by closing the key's selector. Keys can be cancelled asynchronously -- even while the selector is blocking. Second, the selector checks each channel to see if it's ready. If it is, then the selector adds the channel's key to the ready set. When a key is in the ready set, the key's readyOps() method always returns a set of operations that the key's channel can perform. If the key was already in the ready set before this call to select(), then the new operations are added to the key's readyOps(), so that the key reflects all the available operations. selectedKeys() method. If you call Selector.selectNow() and no channels are ready, then selectNow() just returns zero. On the other hand, if you call Selector.select() or Selector.select(int timeout), then the selector blocks until at least one channel is ready or the timeout is reached. Selectors should be familiar to Unix or Win32 system programmers, who will recognize them as object-oriented versions of select() or WaitForSingleEvent(). Before Merlin, asynchronous I/O was the domain of C or C++ programmers; now it is available to Java programmers too. See the sidebar, "Is the New I/O Too Platform-Specific?", for a discussion of why Java is just now acquiring asynchronous I/O. AcceptThread, the first selector just handles the ServerSocketChannel: class AcceptThread extends Thread {
private ServerSocketChannel ssc;
private Selector connectSelector;
private ConnectionList acceptedConnections;
public AcceptThread(Selector connectSelector,
ConnectionList list,
int port)
throws Exception
{
super("Acceptor");
this.connectSelector = connectSelector;
this.acceptedConnections = list;
ssc = ServerSocketChannel.open();
ssc.configureBlocking(false);
InetSocketAddress address = new InetSocketAddress(port);
ssc.socket().bind(address);
ssc.register(this.connectSelector, SelectionKey.OP_ACCEPT);
}
public void run() {
while(true) {
try {
connectSelector.select();
acceptPendingConnections();
} catch(Exception ex) {
ex.printStackTrace();
}
}
}
protected void acceptPendingConnections() throws Exception {
Set readyKeys = connectSelector.selectedKeys();
for(Iterator i = readyKeys.iterator(); i.hasNext(); ) {
SelectionKey key = (SelectionKey)i.next();
i.remove();
ServerSocketChannel readyChannel = (ServerSocketChannel)key.channel();
SocketChannel incomingChannel = readyChannel.accept();
acceptedConnections.push(incomingChannel);
}
}
}
AcceptThread uses connectSelector to detect incoming connection attempts. Whenever the selector indicates that the ServerSocketChannel is ready, there must be a connection attempt. AcceptThread.acceptPendingConnections() iterates through the selected keys (there can be only one) and removes it from the set. Thanks to the selector, we know that the call to ServerSocketChannel.accept() returns immediately. We can get a SocketChannel -- representing a client connection -- from the new Socket. That new channel passes to ReadWriteThread, by way of a FIFO (first in, first out) queue. ReadWriteThread uses readSelector to find out when a request has been received. Because it is only a sample, our server application assumes that all requests arrive in a single TCP packet. That is not a good assumption for a real Web server. Other code samples have already shown ReadWriteThread's buffer management, file mapping, and response sending, so this listing contains only the selection code: class ReadWriteThread extends Thread {
private Selector readSelector;
private ConnectionList acceptedConnections;
...
public void run() {
while(true) {
try {
registerNewChannels();
int keysReady = readSelector.select();
if(keysReady > 0) {
acceptPendingRequests();
}
} catch(Exception ex) {
ex.printStackTrace();
}
}
}
protected void registerNewChannels() throws Exception {
SocketChannel channel;
while(null != (channel = acceptedConnections.removeFirst())) {
channel.configureBlocking(false);
channel.register(readSelector, SelectionKey.OP_READ, new StringBuffer());
}
}
protected void acceptPendingRequests() throws Exception {
Set readyKeys = readSelector.selectedKeys();
for(Iterator i = readyKeys.iterator(); i.hasNext(); ) {
SelectionKey key = (SelectionKey)i.next();
i.remove();
SocketChannel incomingChannel = (SocketChannel)key.channel();
Socket incomingSocket = incomingChannel.socket();
...
String path = readRequest(incomingSocket);
sendFile(path, incomingChannel);
...
}
}
ReadWriteThread registers for OP_READ, while AcceptThread registers for OP_ACCEPT. Naturally, the ways in which the respective events are handled differ; overall, however, both threads are instances of the Reactor pattern. register() is an attachment to the SelectionKey, which can be any object. The key holds on to the attachment for later use. Here, the attachment is a StringBuffer that readRequest uses to receive the incoming HTTP request. Each time readRequest reads a Buffer from the socket, it decodes the buffer and appends it to the request string. Once the request string is finished, readRequest calls handleCompleteRequest to parse the request and send the response. Selector.selectedKeys() is called, it actually returns the Set that the selector uses internally. That means that any other selection operations (perhaps called by other threads) can change the Set. Second, once the selector puts a key in the selected set, it stays there. The only time a selector removes keys from the selected set is when the key's channel closes. Otherwise, the key stays in the selected set until it is explicitly removed. Third, registering a new channel with a selector that is already blocking does not wake up the selector. Although the selector appears as if it misses events, it will detect the events with the next call to select(). Fourth, a selector can have only 63 channels registered, which is probably not a big deal.
The most repeated sentence in code reviews…
Original Source
We all have used this one when blamed for some error…
- Hi Homer, have you removed the debug code from production?
The problem with this sentence is that we use it again the next day, and the next day, and the next day…
The TV series ”The It Crowd” have helped to make this one even more popular…
Why do we keep asking why?
- It restarts twice a day?!! Well that makes sure that the temporary files get deleted!
All code is crap except mine.
For some reason, non technical people use to think that every thing with buttons can be fixed by a programmer…
in-process memcached -> normal memcached -> disk memcached
Posts
All Comments
