Customer Reviews

Multithreaded Programming with Java Technology

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

 

 

The first 150 pages (one third) of this book have little to do with Java. Rather, it is a port of the authors' previous book on POSIX. It talks about three main platforms (Solaris, Digital, and Wintel) and goes into great detail as to how a Java VM uses each OS's primitives to offer Java synchronization. Why?

The authors show bias towards Solaris, and they spend a great amount of time focusing on how you can get the right number of LWPs on Solaris.

If I'm buying a Java book, I'm programming to the Java VM and could care less if Digital Unix gives you one light-weight process per CPU plus one for each outstanding system call. I also don't care about making native calls to the OS under Solaris.

The introduction suggests that multitheading offers increased speed by running on Parellel hardware. I think what people are really looking for is increased responsiveness. Most computers are single-CPU.

The authors are experts in their areas, and they do cover eventually cover multithreading in a no-nonsense manner, with the target audience being the advanced programmer. Don't be annoyed by thier constantly saying, "no, you don't want to do that. Don't do that", and then telling you why in a few more chapters.

That this book was a member of the Sun Java series was the primary reason make me take a look at this book.

I have been highly disappointed. This body of work for this book is primarly a rushed port of the authors other title - named, funnily enough Multithreaded Programming with PThreads.

The Java topics seem to be bolted on as an after-thought - and makes the book read and present very badly. For example a good amount of examples are presented in C not Java, demonstrating POSIX threading!

The author is also in the bad habit of presenting material out-of-order, so that the reader has to wait sometimes 50 pages for clarification. This does not breed suspense, merely frustation at the disorder.

The low-level OS technical coverage is quite adequate - with a good explanation of LWP and POSIX threading (if only this is what I bought the book for!).

The author is clearly a C type who has come to Java and tries to basically recreate the semantics of C POSIX threading in Java... while at the same time constantly drifting back to a topic that he is clearly more comfortable with - PThreads.

This is hardly an embracing approach for a book with the word Java in the title - an obvious cash-in on the behalf of the publisher, Prentice Hall.

Do not buy this book.

This was the first threading book I read--which turned out to be a huge mistake. The material is very dense and only a small part of it is Java. Most of the book deals with operating system threading concepts. There is a lot of space dedicated to contrasting MS vs. Unix threading models. Also, comparisons between Java and c threading.

If you are looking for a solid beginner book on Java threading (or threading in general), I highly recommend Concurrency: State Models & Java Programs. This is the second threading book I read and I highly recommend it if your goal is to _understand_ thread theory and problems. It approaches the subject in a very rigorous manner and models all concepts using finite state machines and then showing the Java source code.

If you are already comfortable with basic threading concepts and some systems programming then I would recommend the Multithreaded Programming with Java Technology.

I deducted a star because of a few annoying typos and for a few convoluted sections.

This is the only book I have seen that thoroughly covers how threads are implemented in a modern OS and how this affects how code runs. It's certainly the most useful book on threading I have. It's a good book to buy after you've written some concurrent code and have some problems.

It's not a Java book - it's a platform focused
multithreading book. It could do with some restructuring to make it more accessible.

If you want a book on Java threading, just to get you by, little cut and paste code and if you read it you might learn something by osmosis, this aint the book for you.

If you want to know all about threading, where it came from (including history anecdotes), what it is, where it's going, all the methods and techniques to managing it all, and from complete knowledge you derive very complete skills in programming... This is the book.

Loses a couple of stars as it takes a way of reading it and full of totally useless diagrams, they mean well though. It is well written enough that the explanations will give you what you need to know, and worse comes to worse you can walk through the code.

Sometimes annoying that Java is most often the last consideration, but as I said, you'll come out knowing everything going on around your code. Because it goes into low level OS threads, you'll come out with understanding as to how different platforms handle the JVM threads so you know wich platform will best run your multithreading program.

Lost stars because up until it all started fitting together, it annoyed the s**t out of me that Java wasn't the prime force in this book, and had to wade through C and Windows stuff.

Reader's opinions are very important to me, after all I didn't write this just to see my name in print. I wrote it because there were no books I found adaquate (that and to become rich, famous, and have beautiful women kiss the ground I walk on).

The one thing which is very true is that this is NOT a book about Java, it's a book about multithreading. I feel it is important for programmers to understand how Java is implemented on lower level libraries and how those run on the actual hardware, and how that hardware works. Not everybody wants to know all of this. (They *should*, but alas! not everyone takes my excellent advice.)

Of course, by trying to cover so much in so little space (I worked very hard to keep it short), I've bitten off an awfully large chunk to swallow. And seeing as you the reader has to do the swallowing... You gotta make up your own mind. Some people do not like humor and computer science in their programming texts. Others love it.

The one clearly wonderful thing about this book is that I got to spend time working with some of the finest computer scientists in the world (Guy Steele, Doug Lea, Tim Lindholm, Dave Butenhof, etc.). I also got to influence the Java 2 spec and Sun's implementation. (Am I bragging here? Oh well.)

The reviews are pretty fair and reflect precisely that problematic issue of depth, Do you want to just write some Java code, or do you want to understand it too? [Except for that last review. This is not good writing?! Poppycock! This is beautiful, elevated prose! This is sophisticated, humorous, precise, concise, incisive explaination, elaboration, clairfication! Profusely illustrated and painstakingly drawn! The Philistine.]

Thus, IMHO, This is one fine piece of computer science literature, destined to become a classic!

-Bil

An excellent book that introduces multithreading in a planned manner. The book starts with a good introduction to concepts of multitasking operating systems and of multithreading. It then explains the underlying principals of threads and its lifecycle and then goes onto advanced topics such as scheduling, synchronization, libraries etc. Of interest were the kernel and thread scheduling models. Also, a good comparison of Win32, POSIX v/s Java API is presented in most of the chapters. I did not come across a book that introduces multithreading so well as this book did. I found the book very useful.

This is a good book, with plenty of information to become a true master of Java threads. You can also become a real wizkid of what not to do when programming threads. For the first 160 pages, there are few Java programs, and the ones that are there, mostly demonstrate wrong ways of doing things. This goes well in hand with the text, which contains plenty of don'ts.

The first part also contains a really good introduction to concepts and lays a good foundation for doing and understanding the programs in the latter 2 thirds of the book, however the rest of the book is well enough written, that it's possible to pick up pretty much anywhere.

Suggestion to future readers: Put every chapter into a thread, and schedule the thread to run, which you find most interesting to the task at hand.

I purchased this book hoping to develop a deeper understanding of multi-threading, the proverbial under-the-hood down and roll-your-sleeves-up nitty gritty. Frankly this book left me quite disappointed. It's poorly organized and poorly editted. While I am sure it has some valuable content, the low readability level and very poor organization (it really gives the impression that it was sort of patched together) prevented me from ever getting into it. In my humble opinion, the book

"Taming Java Threads" by Allen Holub is a fare better choice if you want to master Java threads.

This book is a must for any serious programmer who works with threads. The authors do a great job of explaining not only the basics, but also the most advanced topics in multithreaded programming. This includes advanced means of synchronization, differences between platforms, and an excellent discussion of performance issues. True, the book is not 100% about Java, but I certainly consider this a strength, not a weakness. This book is for those who want to understand what they are doing, and not just blindly follow some code examples. Great book, great achievement.