Customer Reviews

Java Nio

5 star:		(9)
4 star:		(1)
3 star:		(3)
2 star:		(3)
1 star:		(1)

 

 

I bought this book because of the lack of material on java.nio.
The book is a good introduction to java.nio but that is the extent of it. Half the book is an api reference and regular expressions (why is this even covered in this book?).
The rest tells you a little bit about the API, but not how to use it. There are examples, but you have to download them from the internet (ie no CD with the book).

The best chapter you can download for free anyway, so don't bother buying the book. Just download the free chapter and the free examples. The material on the internet from this book covers 90% of what you need to know.

At only six chapters and 282 pages (including the index) one might think "Java NIO" (short for "New I/O") is little more than a cursory examination of the NIO packages introduced in J2SE 1.4 as a response to the Java Specification Request (JSR) #51. Yet, despite its relatively compact size, Mr. Hichens has done a very good job of introducing and explaining the many aspects of this New I/O. The book even includes parts of JSR 51 that are only tangentially related to I/O, such as the new regular expression processing found in java.util.regex and the new pluggable character set mappings.

Chapter 1 is a primer on general I/O concepts and mechanisms and provides a useful foundation for the following information. Beginning with the basics as a foundation is a strategy that Mr. Hichens uses in each of the subjects in the following chapters. It's an important first step, often omitted in books more interested in prose than instruction.

Chapter 2 is a thorough explanation of the various Buffer classes. As the means for data accumulation and manipulation, Buffers are a natural first step in explaining the NIO package. It begins with a fairly detailed basic description followed with sections labeled: Creating, Accessing, Filling, Flipping, Draining, Compacting, Marking, Comparing, Bulk Moves, Duplicating, etc. Each section provides simple yet useful examples of the various operations along with some helpful hints and warnings of potential pitfalls.

Chapter 3 adds about all you'd want to know about the channels used to convey the data into and out of buffer. As the book explains, Channels "are not an extension or enhancement, but a new, first-class Java I/O paradigm. ... A Channel is a conduit that transports data efficiently between byte buffers and the entity on the other end of the channel (usually a file or socket)." In the ensuing sections: Scatter/Gather, File Channels, Memory-Mapped Files, Socket Channels, Pipes and The Channel Utility Classes, the use of channels within the NIO paradigm are extensively explained.

Chapter 4 covers Selectors. Selectors add another completely new ability to Java 1.4. With selectors Java now has a much more sophisticated and integrated ability to do asynchronous and multiplexed I/O. This is obviously very important to anyone dealing with real-time and/or high-demand I/O and it is one of the main reasons for JSR 51.

The book does a very good job of explaining the concept and use of Selectors in chapter sections entitled: The Selection Process, Stopping the Selection Process, Managing Selection Keys, Concurrency, Asynchronous Closability and Selection Scaling.

Chapter 5 introduces Regular Expressions and explains the use of the new java.util.regex package. Regular expression processing was part of the JSR 51 and thus part of this book. While not strictly I/O related, as anyone familiar with Perl can attest, regular expression processing is very useful when it comes to manipulating any textual data used in I/O.

While it covers the Java Regular Expression API very well, it is not comprehensive enough to include the many intricacies of regular expressions. Of course O'Reilly has that covered in Jeffrey Friedl's book, "Mastering Regular Expressions."

The last chapter, Chapter 6, "Character Sets", is a pretty close examination of the actual data moved in I/O and demonstrates how Java 1.4 represents it in the class Charset.

If you've ever wondered about character sets and how they are involved in character encoding or how one character set might be compared with or encoded into another, this chapter will go a long way toward filling you in.

The book concludes with three appendices:

* NIO and the JNI - A more detailed explanation of a new Java ability to use system memory allocated with native (JNI) code. This is one way they managed to improve the performance of Java real-time 3D applications so dramatically.

* Selectable Channels Service Provider Interface (SPI) - Basically explains why this API is beyond the scope of the book and why it wouldn't be useful to anyone not programming a JVM or high-performance App server.

* NIO Quick Reference - Just as the name implies.

In summation, the concepts range from basic to advanced yet are presented in such a way that, even while being explained, the information is understandable and can be used for future reference purposes. The examples are simple yet useful in demonstrating the concepts and the implementation of them. The style is informative and complete yet very accessible and informal. Overall, a well written book useful to anyone needing to know the workings of the NIO packages of Java 1.4.

The book is useful to get started on nio, but you may overgrow it after a week:
it does not delve deeply into the matter. Particularly missing are:
- Mapped byte buffer uses
- Interactions between java & else using mapped files
- OS/platform idiosyncrasies (limits etc)
- Performance analysis

Finally, be aware that half of the book is devoted to regular expressions. The conflagration of nio and regexps is rather strange. I would rather have a shorter book with just a little more depth.

This is a pretty good overview, particularly for those who have no previous experience with non-blocking IO. The author explains the concept of buffers very well, with useful diagrams illustrating the differences between position, limit, etc.

The material on selectors and readiness selection is also strong.

The problem is, there are idiosyncracies to NIO that make it difficult to use effectively for large-scale, high-performance applications without some in-depth knowledge.

If you're really looking to architect a substantial NIO server or client, read this book for the overview, but also be sure to take a look at the open source Netty framework by Trustin Lee, or Ember IO by Mike Spille to see good NIO implementations that you can use as a building block.

No, that's not a mistake the F in the RonF, I really meant it.. in italian "ronf ronf" stands for the sleeping snore, and that's what you will be doing if you try to read this book. I had to struggle with myself real hard to force my way through this book, and trust me, I am used to reading books that are not exactly pure entertainment. The material presented is actually quite accurate and useful, only the presentation style is abysmally boring, arid and schematic. Even the table of contents reflects that, it goes: Buffer - Channel - Selectors - Regexp - Charsets. Every subject is explained pretty much in isolation of each other. How can you possibly put together anything even remotely engaging and conving with a style like that? It's like trying to teach you the english language using a dictionary, first learn all the words that start with A, then let's go to the B...
The irony is that in the intro to chap 1, the author even makes jokes about IO not being so dull as usually believed. Well I agree with him , but he certainly managed to make an outstanding contribution to the dullness of IO. Should he be congratulated?

Every once in a while, a truly outstanding book comes along, that is a must-read for everyone in a given field. This is such a book. Comprehensive yet concise, clear and engagingly written, this book belongs not just on the bookshelf, but in the hands, of EVERY Java programmer. Buy it, read it, and enjoy it.

A good book overall. Java NIO is a pretty formidable subject. The author does a decent job with this material. The details are concise and complete.

What Ron Hitchens did with this book is complete knowledge-sharing. "Java NIO" is just over three-hundred pages, yet, it is big enough to supply developers all the important tuition they need in order to improve their perfomances. This book clearly outlined the best ways of exploiting the I/O capabilities of the newly introduced Java 1.4 version.
It also analyzed the NIO APIs in the most comprehensive way. The interest which the contents of this book arouse makes it an important text for developers and enthusiasts alike. Very few complaints will ever go against it. The only one I have is that it may not be too friendly with beginners.

Actually the small subtitle on the top of the front page "Regular Expressions and High-Performance I/O" would be the better title. "Java NIO" is incorrect. That suggest already that the mere 282 pages are not completely devoted to explaining usage of NIO package. The obvious conclusion is that this book is to terse to grant it the status of the sole source of information on NIO. But wait, there is more: The author feels the necessity to quote the Java package specifications, which we all have anyways on the net. This nonsensical waste of paper starts on the page 238, preceded by several pages of a similarly useless appendix B which quotes java.nio.channels.spi specifications. Thus the book has de facto approx. 230 pages.

But wait, there is more! Already on the page 151 author abandons NIO and devotes himself to a talk about regular expression package, and... in his code examples uses boldly standard java.io. His examples are of a stunning banality and simplicity, to terse to be of any use beyond the regular Java instructional trail on the net.

Regarding NIO, the 150 pages remaining, reader should rather take a look at "The JDK 1.4 Tutorial", 408 pages:
The JDK 1.4 Tutorial. Travis'es chapter 1 and 2 clearly top this text in every aspect. Hitchens code examples seem very arbitrary, and often to verbose, dealing with, or constructing something not pertinent to IO itself. For example, pages 63/65, where author suggest to "wait" in a spinning while loop for write, without any sleep (hm..., is that really necessary?) and later on wastes an entire page on assembling some arbitrary text messages or sentences of a kind. Every reader will make many more such observations.

Not a good call on O'Reilly's part... NIO is very complex indeed, and every practitioner has his/her own set of papers and snippets collected over the time, still waiting for "the ultimate" summary by someone. Last but not least, what annoys me in this book are the nonsensical and banal quotes of someone or something in the beginning of the chapters. This is a very nasty habit, copied over and over again by many authors. Only a few writers have the knowledge and ability to make such quotes, see Donald Knuth to contrast what you will find in this book. For example, "here, put this fish in you ear" by Ford Prefect. I have no clue what that means, and who or what Ford Prefect was. The said appendix with cut-and-paste of Java package specifications starts with a sentence by "U2", what ever that means. The equally useless appendix B starts with "If you build it, he will come" by... "An Iowa cornfield"! I have really no words to comment on this nonsense.

Now let me pack the "NIO users manual" and ship it back to Amazon. Give me my money back!

I had this book sitting on my shelf for awhile, but recently I started a side-project on some open source. I wanted to convert to asynchronous non-blocking IO. Without async non-blocking IO, I had to to either have a thread sitting on a blocking read, or would have to create a new socket for each call. Either choice was poor. I needed non-blocking IO.

Well, I don't know what quite to say.

Certainly I am left with the general impression that NIO is quite difficult to use. Certainly one can find 'demo' examples on the web, yet the ones I have found really don't work. I took a demo example on the web and spent several days trying to convert it to something that could actually handle a series of bi-directional messages on the same socketchannel.

Well, as a piece of demo code, it worked fine for a single message being sent and a response received. But try doing the same thing a hundred times in a loop and it fails quickly.

Still don't have this 'demo' working, as my smoke tests show occasional errors in a series of echo tests. That is, client loops 100 times sending a different message each time to the server, and then client confirms that it received the same message as its reply (or not). Well, somewhat random failures occurred running this code. And this is the state of the code today.

Now back to the book...

Looking at the Java NIO book was not helpful. I read the given sections of the book, and went back and forth between the book and the demo code. Nothing helpful in the book because the book's examples did not show how to produce a reliable conversation between client and server across a socketchannel.

What I really wanted was an example that would show a semi-productionable case of async non-blocking I/O between a client and a server, and that meant that it should have many clients repeatedly calling the same server, again and again and again. While that may be in the book somewhere, I didn't find it. Nothing showing scalability and longevity as far I could see. I would be glad to be corrected.

This brings me to the topic of NIO frameworks.

Looking at briefly at NIO frameworks, my impression is that they had to use state machines and other techniques to build on top of NIO. I believe at this point that there is a lot of "exercise for the reader" work when it comes to using NIO. A *lot*. So in the end, maybe I will need to use a framework to make up for the problems of NIO.

Still where are semi-real examples of NIO code on the web?

It is somewhat indicative that the web is not full of examples of folks who got robust async IO to work and want to share it. Instead, I read one post where a group of professional software engineers took 3 months to get their scalable use of NIO to work in a router application. In the end, it did, and they were very happy with the results. But their post seemed a somewhat cautionary tale.

But the point of a book like this, as I see it, is to save me some portion of that 3 months, hopefully
a large portion of it, and it has not at all. It provides some beginner code, but how to build a scalable server? No.

This review does sound dangerously close to a rant, but I really don't mean it that way.
Scalable async IO is the flagship feature of NIO for many folks, and this book provides only very partial help here. It is like a boat that goes halfway across the river and stops. Maybe just a quarter of the way... I want a boat that takes me across the river, or at least gets me closer to the other side. Or, if it cannot warn me about missing advanced material. It could at least suggest what I would still to learn outside of the book's scope.

The book doesn't do this at all.... For this reason, it would be great if someone wrote a book on async IO and nothing else using NIO. Now that would be helpful!

Now I have still given the book three stars because I think NIO is simply very difficult material. It would be unfair to the author to give him a harsh review given the difficulty of the material.