Java Concurrency in Practice

This is not an introduction to Java Concurrency.
This is not a taxonomic reference-like book that describes the Java Concurrency APIs either.
Rather it is a skilled guide on how to take advantage of the concurrency APIs and constructs to avoid the intricacies and difficulties of concurrent programming.
The reading is technically advanced.

The approach followed often involves presenting concurrency issues, exposing the associated pitfalls with a wrong solution and refining it to properly address the issue.
The reader should be prepared to peruse the Javadoc to complement what is explained in the book and get the full picture of the available APIs.

Thread pools are given ample coverage and thoroughly analyzed (usage, alternative implementations, sizing, configuration, task cancellation, shutdown).
High level (synchronized collections, semaphores, latches, barriers) as well as low level (locks, condition variables, atomic variables) synchronization are covered.

The book predates Java 7 so recent additions like the Fork/Join framework and CompletableFuture are not discussed.
Concurrency issues involved with Java 8 streams are also missing.
Despite the fact that an update would certainly be appreciated, readers can still considerably benefit from the book contents.

Though the book is admittedly very good and valuable in content, the paper quality of the pages is absolutely horrible (as a previous reviewer noted)! One can see through to the next page, and using a highlighter for emphasis is next to impossible. Though not amenable to my style of copious highlighting, the book's content is so superior that I still recommend it.

Yet another review update (6/7/14): I picked-up this book after a few years of a Java-Programming hiatus and can only reiterate how well-written it is. It's amazing how these authors can clarify and explain extremely complex issues so that even old guys like myself can comprehend. And there is not extraneous fluff--every paragraph is chock-full of good info.

Question: Just curious, has the paper quality improved in the last few years?
My book is the "Third Printing, September 2006".

Fantastic book. Sure you can get all of this information online, you can get all the information you want online, but rarely is it nicely crafted to help you learn about the topc you desire. This book is informative, and understandable. They give you warnings and discuss how they made the libraries. Would suggest!

In Sun's official documentation for Java, there are aids on writing explicit multithreading programs. These are ok, as far as they go. But you might find that in an actual non-trivial, non-textbook case, strange things can happen. Deadlocking. Or perhaps low multicore usages. Or ...

This book goes way beyond the Sun documentation. It looks at many aspects of concurrency. Including how to make a thread safe class. Which is one of the basic things you need, given that Java is object oriented, and a typical program makes classes specific to its needs. Here, the guidelines are concise, requiring that you focus on defining the class's invariants and the variables that define the state of the class. The book does not seem to explicitly talk about the concept of a finite state machine. But that is essentially what you might want to consider for each of your classes that will have multithreaded access.

Also well worth attention is the chapter on multithread performance. Germane with the increasing availability of multicore processors. The chapter has a lucid explanation of the costs of having too many threads. You need to strive to minimise the maximum number of threads in your application. Context switching can be extremely costly in terms of time, and greatly reduce the overall efficiency.

The authors correctly point out that this topic, once the realm of advanced programming specialists, is now of concern to all programmers. Technology and the Java language both demand that software artisans understand concurrency and building thread-safe applications. The authors begin with some basics concerning concurrency and defining terms. This is essential since it seems an area where every software engineer seems to have their own definitions and assumptions. With the ground work complete, the authors continue on with various approaches to thread-safety and design considerations.

Included is a discussion of GUI development considerations, performance considerations, and testing strategies. Within an advanced topics section the authors cover explicit locks, custom synchronizers, and the Java memory model with respect to concurrency issues.

The writing style is clear, concise, and readable. Well worth the investment for the beginner or advanced student and sure to be referred to again and again in the future.

Concurrency is hard and boring. Unfortunately, my favoured technique of ignoring it and hoping it will go away doesn't look like it's going to bear fruit. Fortunately, Java 5.0 introduced a new bunch of concurrency utilities, that work at a higher level of abstraction than marking blocks as synchronized and fields as volatile. Unfortunately, there haven't been that many books on the subject - even the good Java 5.0 books (e.g. Head First Java or Agile Java) make little mention of them - Thinking in Java being an honourable exception. Fortunately, JCIP is here, and it is authoritative stuff. And it's (mostly) very easy to understand. Plus, at 350 pages, it's not an enormous chore to slog through. It even covers changes to the upcoming Java 6.

Before tackling this book, you should have at least some idea of pre-Java 5.0 concurrency. You don't need to be a threading master, though, as the first part of the book covers basics like deadlock, atomicity and liveness. This was my favourite part of the book, as it comes with lots of small code snippets, both right and (horribly) wrong, and pithy design guidelines. It's rather like Effective Java in that respect - although the material on threading was probably the weakest part of that book, so this is a definite improvement.

The second part deals with thread pools, cancellation strategies, and GUIs. This is also excellent. Part three covers performance and testing. The last 75 pages are for advanced users and goes into a fair amount of low level detail (including a discussion of the Java Memory Model), which may be of interest to experts only.

I would be lying if I said that reading this book will demystify concurrency completely. Who wrote which bit of the book is unclear (although readers of Effective Java will probably spot parts of the text that seem rather Joshua Blochish), but while it's mostly very clear, some parts of the text are a little murkier than other. Perhaps this is to be expected given the subject matter. But for the most part it's surprisingly easy reading, and very practical to boot.

Let's face it, short of aliens landing and introducing a radically new way of computing, multicores are here for the medium term at least, so thread-dodging wimps such as myself will just have to get used to it. That being so, this book is going to be installed as one of the must-read books in the Java pantheon.

It's common knowledge that you can easily get burned with Java programs that are multi-threaded. I would strongly recommend that if you are going down the multi-threaded path, you *need* to get this book... Java Concurrency In Practice by Brian Goetz. This bridges the gap between what the reference manuals say and how things work in the real world.

Contents:

Introduction

I. Fundamentals: Thread Safety; Sharing Objects; Composing Objects; Building Blocks

II. Structuring Concurrent Applications: Task Execution; Cancellation and Shutdown; Applying Thread Pools; GUI Applications

III. Liveness, Performance, and Testing: Avoiding Liveness Hazards; Performance and Scalability; Testing Concurrent Programs

IV. Advanced Topics: Explicit Locks; Building Custom Synchronizers; Atomic Variables and Nonblocking Synchronization; The Java Memory Model; Annotations for Concurrency

Bibliography; Index

This book picks up from the regular documentation on how specific synchronization and threading features work. Goetz does a relatively light introduction to the topic, and then starts into practical issues that you'll encounter in real programs and applications. For instance, a specific component, such as a collection, might be thread-safe. But what happens if that component is part of a compound function you've written? The compound function may well have "features" that you don't expect when running in the wild, since the threading issues now have to be considered at a level higher than the specific component. And being that you rarely have a clue as to how your program will mix with others, a bad design can lead to nasty intermittent threading bugs that are nearly impossible to consistently recreate. Goetz goes beyond the "write your code this way" material to explain how both code *and* design have to work in concert with each other to make sure a multi-threaded application behaves the way it should.

I was also impressed with the number of examples, both good and bad. By having a large number of "don't do this" samples, it's likely you'll see something that might be common practice in your coding style (but that will need to be changed). He also summarizes the material in gray call-outs within the flow of the text, so you can quickly grasp the one or two line concept that needs to be remembered and internalized in practice.

In a single word, this book can be summed up as "practical". Everything is focused on how things really work, and how to avoid common practices that will lead to major trouble. This is a great addition to the Java shelf of my library, and I recommend it with no hesitation.

This is a book about Java concurrency design, not merely how to use Java thread through a set of APIs.

Authors go through fairly deep on what the challenges are faced by Java developers on designing robust concurrent applications, what should be considered to balance design forces between liveness and safety, how to utilize parallelism to achieve better scalabilities, what pitfalls should be avoided, how to test concurrent applications. A lot of practical examples are given under the context.

Most of "new" components in java.util.concurrent package are explored and analyzed, for what the thoughts are behind, why the design came the way it is and what balance it achieves. These components can be used as a basic building block for composing more sophisticated solutions to meet your application concurrency requirements.

Though the theories behind concurrency are not trivial, the book presents them in a very clear, concise and easy understanding way. It is a truly remarkable book for Java developers in trenches.

I recently bought this book from the store. Just finished Chapter 3. This book is full of real-life advice about designing and delivering Thread-safe classes. More importantly, it helps us (Java Developers) to question whether the 3rd party library we use in projects are thread-safe or not and spot concurrency "mousetraps".

This books introduces a topic usually with a "Bad" thread example and then reasons out the potential deficiencies (race conditions, etc.) that may happen when things go wrong with that code. Then (thankfully!) they propose a alternative correct solution in easy to understand code.

This book also addresses a gaping hole in current Javadocs standards followed by devlopers : not clearly mentioning the Thread-safety aspect of the class.

In all a excellent book and a must read along with "Effective Java".

This book gives a good introduction to how to write multithreaded Java programs. The first few chapters give a detailed overview of how things can go wrong without proper synchronization between threads, but it comes up short in a few areas. One is that there is no good explanation of why Java's memory model is the way it is; a short discussion of modern computer hardware would explain why one thread can see an old value for a variable. Also, discussion of wait and notify is left to the back of the book, rather than being featured as prominently as it should be. Still, it's a must read for anyone who wants to write parallel code in Java.

I've been doing Java development for close to thirteen years now, and I learned an enormous amount from this fantastic book. For example, I knew what the textbook definition of a volatile variable was, but I never knew why I would actually want to use one. Now I know when to use them and when they won't solve the problem.

Of course, JCP talks about the Java 5 concurrency library at great length. But this is no paraphrasing of the javadoc. (It was Doug Lea's original concurrency utility library that eventually got incorporated into Java, and we're all better off for it.) The authors start with illustrations of real issues in concurrent programming. Before they introduce the concurrency utilities, they explain a problem and illustrate potential solutions. (Usually involving at least one naive "solution" that has serious flaws.) Once they show us some avenues to explore, they introduce some neatly-packaged, well-tested utility class that either solves the problem or makes a solution possible. This removes the utility classes from the realm of "inscrutable magic" and presents them as "something difficult that you don't have to write."

The best part about JCP, though, is the combination of thoroughness and clarity with which it presents a very difficult subject. For example, I always understood about the need to avoid concurrent modification of mutable state. But, thanks to this book, I also see why you have to synchronize getters, not just setters. (Even though assignment to an integer is guaranteed to happen atomically, that isn't enough to guarantee that the change is visible to other threads. The only way to guarantee ordering is by crossing a synchronization barrier on the same lock.)

I've seen hundreds of web site crashes. Every single one of them eventually boils down to blocked threads somewhere. Java Concurrency in Practice has the theory, practice, and tools that you can apply to avoid deadlocks, live locks, corrupted state, and a host of other problems that lurk in the most innocuous-looking code.

I think the book is an excellent material not only on multi-threaded subject, but on software architecture in general. Things are said the way they are, without giving false expectations that multi-threading will solve all your performance issues. For instance, very realistic approach on how much concurrency will help, when all the program's tasks are serialized, waiting on each other. I agree with another reviewer that this is a nice complement to Doug's Lea "Concurrent Programming ...", but I disagree that Doug's material was "dry". If you're into multi-threaded (and quite frankly, even if you're not), that one is also an excellent "must read".

Java Concurrency in Practice gives very complete coverage on the language's concurrency classes introduced in Java 5 & 6. It shows you the shortcomings of previous attempts at concurrency in earlier versions of the JDK, with great code samples.

This book is pretty comprehensive and goes through the thinking/theory of why things are written the way they are, it is not just a paper version of the JavaDoc reference.
It is also very, very readable. I am by no means experienced in concurrency problems, but it was very easy to follow through the reasoning and examples. (my background is a CS degree and 1.5 years in the industry)

This book is a must read, especially for Java devs. Even if you are not a Java programmer, it could still be an enlightening read because it tells you how to structure your programs to deal with concurrency and how to deal with concurrent stateful apps, which unless you are using Erlang, is something you have to deal with.

I have been programming in Java for years, and yet I've generally ignored or otherwise avoided dealing with concurrency and synchronization at every opportunity because I found it so daunting. This book broke down that barrier for me and helped me to understand what I needed to do to write correct concurrent programs. In particular, the book provides concrete instructions that I was able to apply to projects that I am working on right now.

I would highly recommend this book to any Java programmer, as you are probably missing out on part of the capabilities of your language (and/or writing incorrect programs!) until you read this. It's probably not a bad lesson for developers of concurrent software in any language, but the concrete instructions regarding Java were really the most valuable part of the book to me.

I purchased Java Concurrency in Practice based on the very high review its gotten. I have been a little disappointed. The book provides a great deal of do's and don'ts but at times (only sometimes) does not provide sufficient explanations. Essentially, the book makes final conclusions at the end of each sections but in some (certainly not all or most) cases, it does not provide sufficient examples, scenarios or details to backup the conclusions so it leaves the reader wondering how in the world did the author come up with the conclusion.

I will provide you with a concrete example:
On page 34, topmost paragraph, the authors state "and a thread other
than the publishing thread were to call assertSanity, it could throw AssertionError" then they elaborate but on the symptom: "The problem here is not the Holder class itself, but that the Holder is not properly published. However, Holder can be made immune toimproper publication by declaring the n field to be final, which would make Holder immutable;" rather than provide a concrete scenario of how the problem would occur. This leaves the reader trying to come up with a a sequence of events that will cause the AssertionError. In general, sometimes, after 30 mins or so, I would figure it out, but sometimes, as in this case, I can not.

On the other hand, the book does provide major practical benefits. For example, I had to refer to the book twice in one month, once to review the caching algorithm using FutureTask and one to trouble shoot a ConcurrentModificationException in JBoss from session replication. Hence, any book that I would need to refer to, however frequently or infrequently, deserves at least 3 stars. It would have been 4.5-5 stars if the explanations/justifications came with more detailed step-by-step replication procedure for all rather than for some. That could turn the book into a 500 page monster so I guess I understand why the authors didn't. Using the above example, I wished they had provided more scenarios of how/why ConcurrentModificationException is caused, in addition to the excellent example they provided (logger.info("...." + set) would generate the exception since set.toString() iterates thru the elements and other threads could be modifying the set).

This book is an essential resource for developer using the java.util.concurrency classes. It is written in a logical path that allows the reader to learn and understand not just the classes to use in writing concurrent applications but also why to write them using approach A versus B versus C.

The use of negative examples is really what makes this book great.
Although certain parts are a real brain tease (with certain pages taking 20-30 minutes of examination to fully understand) you come out with deep understanding that is lasting.

Bravo!

Very simple -- if you need to write a concurrent Java application you must have this book.
The book teaches you more than just the theoretical aspects of concurrent programming such as exclusion mechanisms, liveness and safety issues, it shows the correct way to do it in Java.
A comprehensive tutorial of the concurrency package provided in j2se 5 and 6 is given, and I think it is a crucial aid for writing correct and maintainable concurrent code in Java.
The advanced topics in the book give you a better understanding of the inner workings of Java and even the inner workings of compilers and modern processors and this is done without going into redundant details.

The only comment I have about the book, is that I would expect at least a chapter or two about parallel and distributed programming and the available Java frameworks that support it.

Brian has a winner here. I was fortunate to obtain a preview copy from Brian Goetz and have devoured the book. This is the first book that I know of since Doug Lea's Concurrent Programming in Java, that addresses Java threading and concurrency with such vigor.

Each section has a solid example that will also stand up in the real world.

The book was put together very carefully, with great attention to detail, as is essential for a book about concurrency.

One of the best parts of the book was Brian leading me on all the time. He would show me a piece of code as a solution to a problem, and I would think of ways that it could cause problems. He then addressed those problems on his next page, but caused other problems. This carried on until the final solution, which was always elegant beyond anything I have written :-)

A solid 5 star rating for this book!

Definitely a good meaty book for Java Specialists.

This is the very best book available on concurrency. It covers all the Java 5.0 paradigms and goes from the explanation of volatile/final/mutable/immutable to advanced topics like re-entrant locks.
The best part about the book is Mr Yuk an icon to denote really bad thread unsafe code examples and comparison to different implementations that are correct -you will see from the first day onwards the mistakes that you have been making in your existing code. Very practical; Good explanation, lots of sample code.

Close your eyes look no further and get this book -you will not regret it.

Concurrency is hard. If you plan to write high performant, easy to understand code, or at least understand other concurrent codes in Java, you should definitelly care about this book.

I don't recommend this book for not very experienced programmers however. You should have at least some knowledge about concurrency, ideally from computer science related studies (or books).

If you are Java developer and looking for other alternative, don't look anymore. Read this.

As others have written, this is the best book out there on Java concurrency. I am a decent journeyman coder, not a guru, and this helped me wrap my head around what is involved with concurrency. Concurrency is in many ways orthogonal to the rest of Java programming, so it's good to get a clear and authoritative guide. I still avoid multi-threading whenever possible, but if I have to go there, I reach for this book.

I read other reviews and also impressed with names of authors.
However, the writings are so wordy, and very difficult to understand. I gave up after trying to read 1st chapter. I'll return to this book to try the torture again.

I've read both this book and "Concurrency: State Models and Java Programs" by Jeff Magee & Jeff Kramer, and the difference couldn't be greater. While both books deal comprehensively with the theory and issues behind concurrency, Magee/Kramer's book is too entrenched in using the LTSA tool which then is modeled to match Java 1.1. Conversely, this book is extremely practical dealing with all the latest and greatest enhancements in the Java concurrency world, addressing topics like the Executor model, CyclicBarriers, Latches, BlockingQueue (just to name a few) yet still covers the underlying details of concurrency as well (if not better) than the Magee/Kramer book.

If you need to know about concurrency while developing for Java then look no further.

The book explains in detail the issues of concurrency. Although a complex topic, the explanations are crystal clear. Well worth reading by anyone writing explicit multithreaded code, or implicit multithreaded code such as anything in a J2EE app server.

you can't just synchronize everything... and that's the point of this book. synchronizing is critical but most of us do it incorrectly without a thorough understanding of the jvm. this book has given me some useful concurrency patterns which are sufficient for good programming practice. the part of the book you need to retain is the 'what' to do, the rest of the 'why' to do it is useful but not critical to improve your code.

I have purchased or been given about a hundred tech books over the past two years and read nearly none of them -- except for this one. With the multi-core era upon us, the topic couldn't be more timely and I can't imagine this book being written any better. This is the book I read when I have a spare minute, and I always learn something I can't imagine how I lived without knowing beforehand. Bravo Brian et al.

This is a great book for explaining what is involved with Java concurrency and provides a clear set of rules and guidelines for creating better code (or fixing your existing code). While I knew much of this material before, this book more concisely describes what a correct design needs than I have read anywhere else, and more clearly than I could have described to a colleague. This book should be required reading for any engineer writing multi-threaded Java code.

This is a very little-understood topic, especially among Filipino Java Developers. Reading it came at the right time, just when I'm starting to write some real concurrent apps.

This book helps even if you never plan to DIY concurrency, and are happy to rely on app server functionality. If you will never use concurrent or multithreaded Java - doubtful - JCIP is still useful because it helps you understand some Java concepts in a practical setting.

If you haven't, reading Joshua Bloch's Effective Java first is recommended.

As an experienced programmer (since 1973) with 9 year Java experience, I strongly recommend this beautiful small book for the professional Java programmer. This book has an excellent balance between academic formality and practicality. To gain confidence in exploiting the power of Java threads, do not loose the chance to read and keep as reference this book.

I take the chance to publicly thank all the authors for sharing their knowledge with an excellent, clear and concise style.

Having recently required to use Java in my work I needed a book to help explain the use of concurrency in Java. I have used C++ and Ada extensively in the defence environment for many years working on many multithreaded systems. For concurrency concepts, the book Concurrency in Ada by Burns and Wellings is still the bench mark, however while this is a Java book many of it concepts apply to any multithreaded language. This is a superb book.

The book explains in detail the issues of concurrency. Although a complex topic, the explanations are crystal clear. Well worth reading by anyone writing explicit multithreaded code, or implicit multithreaded code such as anything in a J2EE app server.

you can't just synchronize everything... and that's the point of this book. synchronizing is critical but most of us do it incorrectly without a thorough understanding of the jvm. this book has given me some useful concurrency patterns which are sufficient for good programming practice. the part of the book you need to retain is the 'what' to do, the rest of the 'why' to do it is useful but not critical to improve your code.

I have purchased or been given about a hundred tech books over the past two years and read nearly none of them -- except for this one. With the multi-core era upon us, the topic couldn't be more timely and I can't imagine this book being written any better. This is the book I read when I have a spare minute, and I always learn something I can't imagine how I lived without knowing beforehand. Bravo Brian et al.

This is a great book for explaining what is involved with Java concurrency and provides a clear set of rules and guidelines for creating better code (or fixing your existing code). While I knew much of this material before, this book more concisely describes what a correct design needs than I have read anywhere else, and more clearly than I could have described to a colleague. This book should be required reading for any engineer writing multi-threaded Java code.

This is a very little-understood topic, especially among Filipino Java Developers. Reading it came at the right time, just when I'm starting to write some real concurrent apps.

This book helps even if you never plan to DIY concurrency, and are happy to rely on app server functionality. If you will never use concurrent or multithreaded Java - doubtful - JCIP is still useful because it helps you understand some Java concepts in a practical setting.

If you haven't, reading Joshua Bloch's Effective Java first is recommended.

As an experienced programmer (since 1973) with 9 year Java experience, I strongly recommend this beautiful small book for the professional Java programmer. This book has an excellent balance between academic formality and practicality. To gain confidence in exploiting the power of Java threads, do not loose the chance to read and keep as reference this book.

I take the chance to publicly thank all the authors for sharing their knowledge with an excellent, clear and concise style.

Having recently required to use Java in my work I needed a book to help explain the use of concurrency in Java. I have used C++ and Ada extensively in the defence environment for many years working on many multithreaded systems. For concurrency concepts, the book Concurrency in Ada by Burns and Wellings is still the bench mark, however while this is a Java book many of it concepts apply to any multithreaded language. This is a superb book.

A well-written book that sums up the most important information about concurrency in Java. General introduction to concurrency is just short enough to set up the right context before Java-specific stuff is discussed. Most important rules and pitfalls are highlighted so even just skimming through the book can be helpful, but of course more in-depth reading brings more details. Even if you are familiar with a large part of the presented knowledge, this book presents it in a well-ordered manner which lets the most important issues stand out and helps get a better understanding of the topics discussed.

For me, the most helpful feature of this book are the advices about what not to do -- Best practices on Java concurrency. The authors addressed all the problems I've had with Java concurrency. For those are not using Java 5 yet, it is interesting to remind that the examples are implemented in Java 5.

In terms of the concurrency pragramming, this book is explaining more comprehensive concept and programming model of the thread programming. Also, it is good for upgrading to Java JDK 1.5 programming skills.

To sum, the author introduces the deeper and well understandable thread theory for Intermediate and advanced java programmers.

A comprehensive introduction to concurrency in Java, updated to cover the new executors/thread pools/futures paradigm. Spends a lot of time on the basic concepts of concurrency and then reviews basically every concurrency primitive in Java. I can't recommend this enough.

This book explains a hard topic in crystal clarity. While doing that it provides invaluable expert insight into the topic. Also provides great explanation of java 5 concurrency utilities and how and where they should be used.

Concurrent programming is difficult and if you need to do it, you need this book.

The most comprehensive java threads book I have ever read. It gives an in depth knowledge of Multithreading issues and how to address them in many different ways, either by using the java.util.concurrent package or by the primitives wait/notify/notifyAll. As to the latters, it sheds a clear light on how to avoid issues like missing signals and othersl.

Essential reading. Extremely well organized and written. Everything you need to know is covered in detail. If you have not read this book, it's not likely that you will be able to write correct concurrent applications. There's just way too much to know.

Excellent and timeless work that everyone should read if you are writing Java applications because all apps are now running on multi-processor systems due to progress in Dual/Quad core chip technologies.

This gem of a book is a comprehensive and authoritative coverage of one of the most mentally intimidating programming concepts - concurrency.

The JDK Concurrency API has done a great job at simplifying the concurrency issues. This book, i feel, is a great followup. I can already see those caffeinated developers smiling!

A big thumbs up! Great job!

I am surprised to find the majority of the reviewers rated this book 5. I find that this book is loaded with noise and you will have to wade through the authors excessive obsession to state the obvious over and over again, even in its "advanced topics" section. Such as:

"Performance is a moving target; yesterday's benchmark showing that X is faster than Y may already be out of date today."

Also, some of its examples uses non-standard annotations - @ThreadSafe, @GuardedBy, @NotTheadSafe, etc - that the authors hoped will be part of the JavaSE 7.0 release. (NOTE that this book was written when Java 6 was in beta stage)