Concurrent Programming in Java(TM): Design Principles and Pattern (2nd Edition)

Doug Lea

Concurrent Programming in Java, 2nd Edition surveys a wide field of research in parallelism and concurrency and shows how to do more with multithreading in Java with dozens of patterns and design tips. Written for the advanced Java developer, this book offers a comprehensive tour of leading-edge thinking about parallel coding processes.

Within the dozens of techniques and tips offered here, this book accomplishes at least two goals. First, it shows how concurrency is implemented by default within Java, with material on how built-in features (like the synchronized keyword and its memory model) can be expected to perform when dealing with multiple threads. Naturally, Java threads themselves are also covered, including priorities, scheduling, and the like.

Much of this book looks at ways to improve performance of concurrent code beyond the simple default strategies. After defining criteria for measuring concurrent code (such as safety and "liveness," a measure of running live threads effectively), the book presents dozens of techniques for letting threads work together safely. For the working Java programmer, coverage of patterns that have been implemented in the downloadable java.concurrency package will be the most immediately useful. (Within this nearly encyclopedic survey, short code snippets are used for every pattern and concept.)

Though theoretical at times, this book offers plenty of ideas and sample code to get you started thinking of ways to improve multithreaded code.

Impressively comprehensive, Concurrent Programming in Java offers a veritable bible of techniques for doing two things at once with threads in Java. It's a worthwhile guide to the state-of-the-art strategies for improving the performance of your Java threads. --Richard Dragan

Topics covered: Threads and concurrency in Java, design considerations (safety, liveness, and performance), Before/After Patterns, layering, adapters, immutability and synchronization, deadlock, resource ordering, the Java Memory Model and concurrency, using the java.concurrency package, confinement, refactoring for concurrency, mutexes, read-write locks, recovering from failure, notifications, semaphores, latches, exchanges, transactions, one-way messages, worker threads, polling and event-driven I/O, parallelism techniques (fork/join, computation trees, and barriers), Communicating Sequential Processes (CSP).

1 Will make you a better programmer, but not for beginners.
This book is great but don't read it as your first introduction to Java threads.

This book is not about Java threads per se, but more about design patterns and good object oriented programming practices as applied to concurrent programming (hence the title). Doug Lea is a university professor and this book has a very academic style, including a ton of references to an impressive array of concurrency and object oriented research. While this makes the material somewhat dense, it is very thorough and thankfully supplemented by actual code snippets (Doug Lea also makes significant contributions to the Java SDK and writes great code).

Especially notable are the sections on semaphores and locking in general. Users of util.concurrent (which directly supplements this book), and even the new Java 5.0 concurrency utilities (which were written by Lea and company), will get tremendous value out of these chapters as the locking strategies form the backbone of the higher level classes found in those packages.

For beginners, read "Java Thread Programming" by Paul Hyde, and then try this book.

2 "This is Phylosophy of concurrency".
This is not "concurrent programming".This is only "philosophy of concurrency".I think so too.

3 Excellent, Deep & Clear
Doug Lea does an excellent work.
On the one hand, he does much more than cover the API. He teaches you to *think* & understand multithreades. Example: he doesn't just state the java API won't let you modify a datastructure while iterating on it. He goes further to explain *how* java prevents this, and then details several methods to work around it. This particular example has greatly helped me with a project I'm on.
On the other hand, I found the explanations clear and easy to follow. Great book...

4 Everything you need to know about concurrency in Java
Concurrent programming is fraught with peril. It's much more complex than sequential programming in every meaningful way from specification to unit testing. But if you want to do it right, meaning balancing liveness with safety for efficient and robust multi-threaded applications, you need Doug Lea's "Concurrent Programming in Java". Especially if you need to design an extensible framework with concurrency; well-known examples of such frameworks incluce Swing, most of java.net, and just about every aspect of J2EE.

Lea provides an intense introduction at the level of an advanced undergraduate course. It's fairly academic in tone, because he takes the time to provide thorough definitions and detailed examples. As a former academic who now designs and programs for a living, this is just what I was looking for. But don't buy this book expecting a cookbook of code to cut and paste. It's much more about providing you the fundamental tools to design your own concurrent classes, applications and frameworks.

Lea presupposes the user is fluent in Java, knows a bit about concurrent programming patterns involving mutexes, semaphores, etc, and is familiar with the basic object-oriented design patterns. If you're not up to speed in these areas, the path I followed was reading the following:

* Lewis's "Threads Primer" (warning: it's C/unix-based),

* Gosling and Joy's "Java Programming Language",

* Bloch's "Effective Java", and

* Gamma et al.'s "Design Patterns".

Even if you don't buy this book, consider using Lea's concurrent.util package available from his web site. It provides solid implementations of everything from simple mutexes to concurrent read-single write wrappers for Java collections (Sun's own wrappers simply synchronize all methods, which suffers reduced liveness compared to CRSW designs). And it's both elegantly designed and thoroughly javadoc-ed.

The first edition was great, and I've just finished reading the second edition cover to cover and it has taken my understanding of concurrent design to a new level. Just be warned that this book's not for novices or hobbyists; it's for programmers who need to design the guts of concurrent systems the "right" way and then implement them in Java, especially for extensible frameworks.

5 Good for experienced programmers, but not as intro
The book is a valuable resource for experienced programmers who are trying to write large, complex, real-life concurrent Java programs. The book discusses in depth many concurrency-specific issues you can run into, especially with Java. It gives tons of useful advice (in rather abstract form), both in text and in code (see the book's website for more complete examples). The book is full of useful frameworks and patterns.

However, it make take you a while to understand most of them. The author is fairly careless about the reader, and lets the reader do all the work. To understand one paragraph you may have to browse through 10 other pages, because that parargraph would reference them directly or indirectly. For example, to understand what is meant by "volatile" or "ThreadLocal", it helps to read several pages that precede these terms (and in other instances, you'd have to read several pages that follow). In other words, the book is not easily digestible, and many sections have to be chewed and re-chewed. The best way to approach the book would be to read it in "circles/spirals" and "in no particular order".

On the whole, the knowledge and understanding you get out of the book is worth the effort, but, I wish the author showed a bit more understanding for the reader. With a bit more work, the book could have been not only informative but also readable. For now, its readability is on par with a dictionary.

6 IQ test
I agree with other reviewers that this book is hard to read and understand. To me this is more like an IQ test, if you are smart enough then you get it, otherwise, get lost and those who gave this book 5 starts will simply say: he does not understand a thing but the book is really great.
So, all my fault, I should not buy this book at first and since I've bought it I should nod my head and say:
"hmm, that's right, this is really a wonderful book."
I wonder why the author didn't write this book in Chinese.

7 Future of concurrent programming in Java?
Doug Lea's util.concurrent library, or something very similar is currently under evaluation for inclusion in JSDK 1.5. Java synchronization primitives as it stands are still too low level for many applications. Developing multi-threaded applications is difficult - even deceptively simple constructs like read-write locks (concurrent reads, exclusive writes) are notoriously difficult to get exactly right. This book assumes some familiarity with the basic Java synchronization primitives since it doesn't dwell much on explaining them. It isn't a reference manual on the util.concurrent library either. What this book does quite successfully, is bridge academic theory and practical programming to help the patient reader develop a real understanding of concurrent programming. Most programming books focus on the "what" or "how-to" aspects - this tackles the "why". A useful book considering there are currently very few design patterns, and refactoring strategies available to resolve concurrent programming problems.

8 Thick, dense, but why?
This book is thick, dense, and not as good as other's think it is. (But it isn't without value to the RIGHT audience).

In summary:
The write style makes it hard to read.
The organization makes it hard to read.
Don't kid yourself that this is anything other than a book about Java multi-threading
There is more theoretical information in here then you are likely to find in other Java multi-threading books if you can slug your way through it. (and I mean useful theoretical information).
If this is your first try into multi-threading you should probably look elsewhere. (I would only rate this book as a two star for beginners).

The details:

The book is written in a very academic style like a very long conference paper. Now don't get me wrong, I get tired of the O'Reilly down home writing style after a while as well, but I have seen better writing (through not by my hand) that makes things clear and easy to understand. I think one of the reasons this book is dense is that the writing is not as clear or as well organized as it should be.

While there are many parts of this book that do apply to multi-threading in general a lot of it does not. Believe it or not but the Win32 API provides a vastly superior threading library than Java does. (I don't know if this is part of Java's keep it very, very simple design philosophy, the need to run on many platforms so use the least common denominator approach, or something else. I do wish SUN would fix the threading API like they fixed the first Java windowing api however since it is frustrating to work with). So there is a lot in the book that does not apply to C++ multi-threading on Windows (and I suspect most versions of UNIX as well) and since the author does not mention what is and is not applicable I would NOT recommend this book as a general multi-threading theory book thinking you can apply what is in here to other languages and platforms blindly. (You could end up doing something the hard slow way because you are unaware of the fact that you can wait on several locks at once in other platforms - as only one example).

Now don't get me wrong, if you are doing Java multi-threading only and you want a strong theoretical base to work from and you have the time to sit down and read this book, I'd say it's worth it. If you need to know the basics in a hurry you may want to look elsewhere. (Somebody else here mentioned Oaks & Wong - I haven't read that book but it might be worthwhile as the first read on the topic).

I would not read this as my first book on multi-threading. If you've done multi-threading work in Java or on other platforms then this could be your first book on Java multi-threading.

9 Deeper than you first realize
This is an excelent book. Basically, it's a thorough review of concurrent programming with Java thrown in so people will buy it. The information is presented in a very clear and straight forward manner, and applies to concurrent programming in any language and platform. This should be a classroom textbook. I consider myself experienced in multithreading, and after this book was highly praised by a coworker, I read it looking for big revelations. I didn't get any ... until I finished the book and thought about what I had read. This book reviewed the fundamentals I hadn't thought about for a long time. After all, if you have thought about memory concurrency models and proper data hiding between threads, avoiding monitor deadlocks becomes much easier. To me, the big downside of this book is that even though this book is written so that it can be understood by a novice, a novice will not realize how important and far-reaching the 'simple' topics are!

10 Fantastic
Anyone who says this book does not perform for a working programmer just doesn't have a Computer Science background. When learning something like threads, their issues, and common design patterns, that is the best basis for learning them. This book teaches threads from a Java standpoint, perfect for a Java programmer, but its real use stems from the fact that the knowledge derived from it is reusable again and again and applies to concurrent *and* sequential programming. If a reader were expecting some magic java cure-all, then they probably should not have been reading a book on an advanced programming topic in the first place.

11 Probably the best Java book I've read
Definitely the best book on Java threading on the market and, in general, one of the best books on Java that I've read (I've been programming Java since it was in alpha). The authour explains complex issues in a simple and succinct way without compromising the deeper aspects topic. If you are looking at a "quicky guide to threads" then this isn't the book for you... but in that case, you probably shouldn't be doing concurrent programming. This is a challenging topic and the book does an excellent job of making it accessible to knowledgeable Java programmers.

12 do not expect to get suspense
Although Doug Lea works for Sun and built essential parts of the Java platform, this does not make him a good author. I had to get up to date with Java threading and bought this book. Mistake. From the computer science standpoint it is excellent, but as a typical project constrained programmer I found it absolutely boring. The author steps through the different chapters and subchapters as if he was trying to fill a "this is all I know about threads" list with life. No suspense, no "I could use that", no explaination of common pitfalls... I fell asleep a couple of times reading this book. Next to "deadlocking" Java threads can pose lots of other problems that this book does not cover. For instance threads and Swing or building an event dispatcher that works. A book that covers all that and that I hereby recommend is "Taming Java Threads" from Allen Holub. Two stars, ...it is solid but not useful...

13 Excellent even if you don't use Java
Think multithreaded programming is going to be easy? Think again. Unless you are working on very simple code, multithreading is hard.

The goal of this book is to describe some general solutions to the worst of the common problems in multithreading. Sample code is written in Java, but the theory applies to any object-oriented situation. Read the book and you will save yourself a lot of trial-and-error learning.

Some people complain that this book doesn't have enough working examples. Working examples are nice for beginners, but they are distracting for people who are more experienced. This is important - if you are looking for a handholder, this book will disappoint you. Try "Java Examples in a Nutshell" or another book for beginners. Multithreading is abstract and requires a firm background. If you are ready to work, this book will reward you.

Another book to try, even if you are using Java, is "Pthreads Programming: A POSIX Standard for Better Multiprocessing". That book is aimed a C programmers, but again, the general principles apply. The nice thing about that book is it works at a low level, so you can really see what's going on.

14 Excellent even if you don't use Java
Think multithreaded programming is going to be easy? Think again. Unless you are working on very simple code, multithreading is hard.

15 Best Java threads book for working developers
There are only a handful of books out there that address how to implement sophisticated concurrent development techniques in Java, and this is the best of them. It's definitely a book for working developers though; if you're like me you visited concurrency ad nauseum in your operating systems class(es) in school, and want to get down to business with multithreading in Java instead of rehashing semaphores or POSIX threads or any other topic which won't contribute a whole lot to a real Java project. That being said I would definitely recommend either Silberschatz or Magee for a solid treatment of academic concurrency issues, although this book could suffice for a lot of people as it does discuss semaphores, monitors, transaction protocols and CSP to a good degree.

Incidentally, it warms my heart to see that few Amazon users (3/26 for one review, 8/18 for the other) pay any attention to idiots like arthur who choose to conduct a flame war via book reviews, being clearly ignorant of both the subject matter and the forum in which it's being discussed (throw in basic grammar and syntax while you're at it). Hopefully he'll get his NNTP configuration back in order so he can return to alt.flaming.loser, and leave the pros alone.

16 Great book for the real world
If you are a java developer who needs to design a real concurrent application you will be glad you bought this book. Concurrent programming brings with it a special set of problems and explains behaviour (for example, in the java memory model) that can safely be ignored in a single threaded environment.

Doug Lea presents real world concerns and guides the reader through the design strategies that can and should be used to address them in a safe and reliable fashion.

If you are looking for a "threading cookbook" (see previous review) that presents the API in a recipe style structure then this book may not be for you. If you want to become a qualified "threading chef" who is able to reason and apply sound concurrency principles then this book will teach you much of what you need to know to be successful.

17 Outstanding
This is unquestionably the best text on concurrent andmulti-threaded programming in Java, written by one of the few peoplewho truly understands the subject. If you or your team are writingmultithreaded software in Java (and this includes awt and swingapplications as well as server side), you simply must take the time tostudy this book. You need CPJ just as much as the JLS or the JPL: it'sessential and you will be rewarded many times over for theinvestment. This is one of the few excellent Java books. If you arenew to concurrent programming, you may want to start with Kramer &Magee's book first.

Understanding Java concurrency requires one tostep outside the language proper: it's neccessary to stop pretendingthat Java is platform independent in order to write reliablemulti-threaded code. You will have to understand the Java memorymodel, how OSes manage threads natively and you will have to make theeffort to grasp some difficult material...

18 Get the book on your hands
Again;

1) Get to a library and check out the book on your own.

2) I hardly grasp the utility of the code (or in most cases pseudo-code) examples, and Yes! they would be good for a "Java Mutithreading for dummies" book.

3) The book contains 236 (? ) references to scientific papers (In order to be objective, I took the time to count them)

4) As you yourself admit resorting to language subtleties, this book is more about the philosophy of concurrency than Java concurrency and again there might be nothing wrong with the book, just its name.

Good news is there are options with realistic - Java Multithreading - expositions out there; like Concurrency: State Medels & Java Programs, Jeff _, Jeff _, Jeff _, ISBN 0471987107, for example.

Arthur

19 Good overview on concurrent programming issues
Lea's book covers a wide variety of issues regarding concurrent development, and in adequate depth for what I believe to be the intended audience, namely working developers and not computer scientists nor students with no prior exposure to concurrent development. The solutions to standard problems described within are for the most part well-accepted, but presented with a minimum of fuss allowing one to see the end results without endlessly pondering alternatives. All in all I think this is a solid book written at an intermediate level of difficulty with useful applications for working developers. As an aside, don't be put off by reviews like that of "arthur" below; the fact that he completely misses the point of a simple code fragment (if the operation were performed as n+=2; instead of n++;n++; then n could never be odd and it wouldn't be possible to illustrate this simple data race example, which is still too much for arthur to handle) demonstrates vividly that this book is not ideally suited for those with no prior experience with concurrent development, or people like arthur who think anything but a "For Dummies" book is high-falootin'.

20 A must-read for serious programmers
Concurrency is difficult to get right. If you're going to be doing concurrent programming - in any language, really - then you should have this book in your toolchest. Even if you've been doing multi-threaded programming for years, CPJ is likely to make you better at it. The book represents the latest thinking and advances in concurrency, and judging from the increase in scope over the first edition, it would appear that the state of the art is evolving rapidly.

The second edition is a big improvement over the first: it's better-organized, better-written, and covers much more ground. It also has better treatment of Mr. Lea's "util.concurrent" package, a set of useful synchronization classes that will undoubtedly find their way into the Java platform at some point.

This is a hard book to read, which is undoubtedly why it gets so many negative reviews from confused readers. You can't just browse through it in an hour and then expect to be able to write a multi-threaded web server. It covers enough material to fill a grad-level course in CS, and it helps to have a CS degree or the equivalent to get the most out of it. There are probably much better books out there if you want to get "up and running" with threads quickly. If you ever hope to do anything reasonably complex with threading, though, you should get this book and study it carefully.

21 Was this book about Concurrency in Java?
Java threading is a very fishy issue, the most OS dependent side of Java, hard to fully understand/debug/optimize. I was/am looking for a good book on the topic, but some authors think that writing a book is about showing off they know about(have dedicated their entire livez to) their domain of expertise. I was just looking for a book about well, ... "Concurrency in Java", but the author went on boasting about his general knowledge of concurrency talking too generally more about OS's than Java itself. This book is, indeed, very little about Java, I wonder what is the fundament for the - SO - favorable reviewes by other readers. Maybe the whole intention could be clear with a better title "Introduction to the Philosophy of concurrent programming, with some Java dressing". But then the book wouldn't have been bought by anyone, who blaims him, Sun, Addison Wesley. Some people forget that the cooking business is primarily about making food, and programming is about writing code. There are no running examples in Java, of the like you can find in "Core Java 2", by Horstman/Cornell, to illustrate what he is talking about; just sort of pseudocode with Java sintax, the author in some cases, openly recognizes it, stating: "no implementation code". You could check out yourself what I am talking about getting the books on your hands and going over it, try to find only one explanation backed by a running example. In some the best adjective that fits to describe his examples is practically "stupid". While talking about Synchronization Section 2.2 Pg. 75, he describes the following class: class Even{ private int n =0; public int next(){ ++n; ++n; return n;} } When class Even{ static int n=0; public int next(){ n+=2; return n;} } Would solve this problem without any further mystic and blah, blah. I could possibly write a book about semiotics, with a lot of blah, blah on it, backed by a lot of literature with impresive names, then ask Addison Wesley for a catchy name and even make money out of it, but would it be instructive to other people? Again this is only my opinion, and I am also interested in "Phylosophy of concurrency", you should check out yourself before paying for this book. To at least know what you will get.

Thanks

22 Read It Slowly
I bought CPJ because I had a concurrency problem at hand (writing a an efficient cancelable timer class) and had hoped to find a quick solution here. But what! Doug Lea is not in a hurry and takes his time to introduce and explain all the nitty-gritty of Java concurrency. I thought it wasn't necessary to learn about all this, but now I agree that you need to see the greater picture before you go off and implement even small solutions. Reading this book leaves me wiser than ever before and confident I could attack almost any concurrency problem in Java! (And it took me two weeks to solve my problem, when I reached page 200 or so, and it was piece of cake then.)

23 Good book if you have experience in Patterns
If you know what Design Patterns are and how to apply them then this is good book. It covers the basics of Concurrent programming and then explains some patterns based on these concepts and how can they be applied. However, if you don't have ANY clue what patterns are; you might find this book a little out of your league.

24 I just don't get it...
I just don't understand how this book got all these 5 star reviews. I don't consider myself a beginner -- but I just could not read this book. It just jumps all over the place, using terms not in common practice, and not really building on anything.

There were times I struggled to understand a concept only to realize that it was just something really simple. Other times, the topic ended just when it was getting interesting.

25 Sets new standards in the world of IT literature.
Yes, this material is tough, but this is because concurrency is a tough subject. Folks who don't realize this have usually been fooled by the deceptive ease with which one can create, start and synchronize threads in Java.

The author presents the principles of concurrency in a structured and lucid manner. He presents patterns which have proven successful in concurrent applications, and at the same time exploits patterns to the full as a means to communicate the concepts.

The new information which has been added concerning the memory model, cancellation and portability are welcome additions to the first edition.

Indeed, from cover to cover, the contents of this IT masterclass are *juicy* to say the least!

26 Excellent
Simply a great book on concurrent programming in Java. This book and the class library the author provides are an awesome combination. While some of the information is Java specific, this book is much more about concurrent programming in general.

The author explains the primitive concurrency mechanisms provided in Java, such as Threads and Monitors, and then quickly moves on to higher level abstractions that embody many of the patterns found in multi-threaded applications. By encapsulating these, sometimes complex, patterns in reusable classes, the author shows how to maintain the separation of concerns between the concurrent aspects of the code and the logic of the task at hand.

This book contains a thorough discussion of the topic and extensive code - both examples and a reusable class library. This is a must read for every Java developer.

27 Doug Lea Makes allBlevoloskovolokians Proud
In the great land of Blevoloskovolokia there are few books allowed by the government. Their strong censorships laws current prohibit all books except those by Marcel Proust, and soon Doug Lea. Doug Lea's book does a fabulous job of explaining Concurrent Programming in Java, a topic that all common folk should be well informed about. I strongly urge you all to buy several hundred copies of this book. It is fabulous and you won't regret it.

28 Well worthwhile
Really informative. Seems to offer a "2 in 1" deal where it provides information on both concurrency and patterns. Not a light read as was the case before but the information is worth the effort.

29 Good Solid Information
This is a good, solid book. I don't understand some of the comments here - although not aimed at people with little programming experience, it is not impenetrable or badly written. It is not an academic textbook, but neither is it an inspirational classic. It's simply a good explanation of many of the issues involved in concurrent programming - the best I have read.

An experienced Java programmer who has already used and worried about threads could read this in a couple of days and learn a great deal - at least, I certainly did. The emphasis on patterns really helps - this is the first book I have seen that uses patterns as a tool and succeeds. They clarify the argument and let the reader decide whether they want to continue with a particular section or skip over to something more interesting.

Some of thread programming is difficult and, at least at the moment, there is no way to avoid thinking about the problem - but even in the detailed discussions of the final chapter, concentrating on particular examples, there were useful general comments.

My only criticisms are: (1) The organisation of the book wasn't as clear as it could be - it wasn't until I had read it from cover to cover that I felt I could find particular items of information. (2) There was little mention of Hoare's CSP/occam and the related Java work done at the University of Kent (I'm not an expert on this, but I found that work very useful and wished it had been discussed here). Amazon doesn't seem to like links from its pages, but I am not connected with these people and think readers here would be interested in this, so please - leave in this pointer: http://www.cs.ukc.ac.uk/projects/ofa/jcsp/ Thanks!

Incidentally, if you are hoping this is a manual for Doug Lea's respected concurrency package - it isn't. I read the book hoping it would be, but I wasn't disappointed because, once I had finished the book, I found the package (with the online docs) easy to understand. So the book complements (and funds!) the package, but isn't a manual - it's much more useful than that...

30 Well worth the effort it demands.
Although this is definitely the most difficult programming book I've ever read, it has also been the most valuable. Java threads are either very simple or very complicated, depending on what you need to do.

For the simple things, even a general introduction in a book like Core Java will do.

For the complicated things, nothing but this book will do. It will reward detailed study like few other programming books I've read.

Give the O'Reilly book to your boss to explain what it is you're doing and why, then use Doug's book to get to work.

31 It's a good book, but it may not be worth the effort
The other reviewers weren't kidding about this book being dense and difficult to read. The problem I have with it is not its difficulty but because most of it is cause by poor presentation and organization rather than the subject itself.

32 heady stuff
Beginners don't bother. But for real programmers, this is a great book, albeit not a particularly easy one.

33 Extremely Theoritical
This book mainly goes over the theory of Java Threads and works more as a guide to thread programming than a how-to book. Although the infomation inside the book is informative, more details regarding the thread classes and examples of their use is what is missing from this book. If one already know the java thread classes and wants better design in their programs, this is your book. If you are starting out and know nothing of threads or the thread classes, search elsewhere for help.

34 Way over my head!
I tried hard to understand the content of this book however,it made litte or no sense to me. I am a novice Java programmer but have several years of experience in other programming languages. Don't go for this book unless you're a very experienced with Java. Java consultants who work with me admit they understand only parts of this book.....

35 Excellent for the experienced
I found the book to be excellent because I need a book that would allow me to map my knowledge of concurrency from other languages to Java. The book covers a lot more than just the syntax, such as providing the theoretical side of handling concurrency and the design patterns involved.

If you are a novice to concurrency, then the theoritical side will do you a lot of good. For myself, it was a good refresher.

The book is definitely worth the money.

36 Poorly Written, Poorly Organized
Writing a good programming book requires more than knowledge of your subject-- the would-be author must also know how to write. While Mr. Lea undoubtedly knows his subject, the resulting book is not only poorly written, but so unorganized its worthless as a reference. For example, endless numbers of variations on each type of Thread architecture are presented with little attention paid to the implications or potential for use in a particular situation. The result is the book reads more like "all of the things I could think of about threads off the top of my head" rather than a text meant to instruct the reader.

For examples of a higher standard take a look at Programming with Threads, by Kleiman, Shah, and Smaalders, or Java Network Programming by Hughes, Hughes, Shoffner, and Winslow.

37 No pain no gain - and the gain is substantial
Doug covers some complex concepts in multithreading that go beyond merely describing how to multithread Java applications. Although difficult to read this book provides many insights in how to apply multithreading in any environment to the safest and best benefits. One of the best books I own.

38 Powerful, difficult and rewarding book
This book goes WAY beyond basic Thread constructs and APIs. Written with extreme brevity (and therefore demanding of the reader) it is a classic among Java books and will consistently reward you through multiple re-readings. This is the most difficult of Java books to read but it is by long and far the most potent.

39 Awful! Save your money.
The author provides no insight into how Java concurrency actually works, or how to best exploit it. His style is full of obfuscation and needlessly difficult to read. Just as K&R's C is known commonly as "the white book," Lea's "Concurrent Programming in Java" is known around here as "the badly written book." Skip it.

40 A musthave for multi threaded programming
This book is a must have for multi threaded programming, just as Stevens' "Unix Network Programming" was to tcp/ip socket programming. It is a book one would come back to read time after time. There are many code examples to illustrate various design patterns. It is definitely an advanced book beyong API and language tutorials. Just as Stevens' book, it is worth its weight in gold.

41 Not light bedtime reading
I have both Doug Lea's "Concurrent Programming in Java" and Oaks and Wong's "Java Threads". Doug Lea's book is by far the most comprehensive. The book focuses strongly on applied uses of locking mechanisms and covers a great deal of the theoretical basis of monitor-based locking schemes. The book is not easy reading though -- it is extremely dense. It has applicability outside of the Java programming environment and I recommend it to you if you are interested in the theoretical side of concurrent programming. Oaks and Wong's book is far less academic. It is an extremely easy read. Notwithstanding the fact that it is 250 pages, it can easily be read (and understood) in an afternoon. Their approach is much more practical and focuses on Java's support for concurrent programming. If you need to dive into multi-thread programming in Java then I heartily recommend this book to you as it will get you started quicker than Doug Lea's book. If your interest is in concurrent programming in general or if you are using a different language, then Doug Lea's is probably the more suitable.

42 Exploiting Java's most under-estimated strength
Writing concurrent programs properly is hard. Java has excellent support for multi-threading, but you still need a really good tutorial to explain the issues and solutions. This is it. It's also the first use of design patterns that made me feel I understood them rather than admiring them from a distance.

I'm not an expert, but I would say that Doug Lea knows the subject inside out, and succeeds in making it "as simple as possible, but no simpler" ((c) A. Einstein). I admit I would have liked some exercises, but the proof of the pudding is that my multi-threaded web-application stress-tester works!

43 A great resource for those that can keep up with it.
While Doug Lea does an excellent job of covering concurrent programming in Java, he falls short of perhaps his toughest battle -- bringing it into the grasp of the less saavy reader. The book nearly requires that the reader already have a much higher level of technical knowledge, comprehension of Java, and object oriented design than the other books in this series. He does, however, a wonderful job of covering the Java constructs for concurrent design. Unfortunately, each example has several prerequisite examples. As such you need to flip back several pages any time you want to know fully understand a given example. This can make using this book as a reference much more difficult. If you're willing to work through the technical details of the book, it does do what it set out to do

44 a must read for software designer/modeler
This book not only covers concurrent programming techniques (which is *very* useful btw), it also addresses more important issues of OOA&D applicable to Java, that is, reader gets not only useful examples of code, but learns *how to* design & model Java applications. Which is IMHO is much more valuable than the rest of the books going over the language implementation specifics. Great job!

45 An Absolute Must-Have for Concurrent Object-Oriented Design
Most Excellent! Doug Lea discusses concurrent OOD and OOP issues which I have found nowhere else. This book is a must-have for any OO designer/programmer intending to use concurrent techniques. The principles and patterns presented are applicable to implementation in any OO language.