"I was fortunate indeed to have worked with a fantastic team on the design and implementation of the concurrency features added to the Java platform in Java 5.0 and Java 6. Now this same team provides the best explanation yet of these new features, and of concurrency in general. Concurrency is no longer a subject for advanced users only. Every Java developer should read this book." --Martin Buchholz JDK Concurrency Czar, Sun Microsystems "For the past 30 years, computer performance has been driven by Moore’s Law; from now on, it will be driven by Amdahl’s Law. Writing code that effectively exploits multiple processors can be very challenging. Java Concurrency in Practice provides you with the concepts and techniques needed to write safe and scalable Java programs for today’s--and tomorrow’s--systems." --Doron Rajwan Research Scientist, Intel Corp "This is the book you need if you’re writing--or designing, or debugging, or maintaining, or contemplating--multithreaded Java programs. If you’ve ever had to synchronize a method and you weren’t sure why, you owe it to yourself and your users to read this book, cover to cover."--Ted Neward Author of Effective Enterprise Java "Brian addresses the fundamental issues and complexities of concurrency with uncommon clarity. This book is a must-read for anyone who uses threads and cares about performance." --Kirk Pepperdine CTO, JavaPerformanceTuning.com "This book covers a very deep and subtle topic in a very clear and concise way, making it the perfect Java Concurrency reference manual. Each page is filled with the problems (and solutions!) that programmers struggle with every day. Effectively exploiting concurrency is becoming more and more important now that Moore’s Law is delivering more cores but not faster cores, and this book will show you how to do it." --Dr. Cliff Click Senior Software Engineer, Azul Systems "I have a strong interest in concurrency, and have probably written more thread deadlocks and made more synchronization mistakes than most programmers. Brian’s book is the most readable on the topic of threading and concurrency in Java, and deals with this difficult subject with a wonderful hands-on approach.This is a book I am recommending to all my readers of The Java Specialists’ Newsletter, because it is interesting, useful, and relevant to the problems facing Java developers today." --Dr. Heinz Kabutz The Java Specialists’ Newsletter "I’ve focused a career on simplifying simple problems, but this book ambitiously and effectively works to simplify a complex but critical subject: concurrency. Java Concurrency in Practice is revolutionary in its approach, smooth and easy in style, and timely in its delivery--it’s destined to be a very important book." --Bruce Tate Author of Beyond Java "Java Concurrency in Practice is an invaluable compilation of threading know-how for Java developers. I found reading this book intellectually exciting, in part because it is an excellent introduction to Java’s concurrency API, but mostly because it captures in a thorough and accessible way expert knowledge on threading not easily found elsewhere." --Bill Venners Author of Inside the Java Virtual Machine Threads are a fundamental part of the Java platform. As multicore processors become the norm, using concurrency effectively becomes essential for building high-performance applications.Java SE 5 and 6 are a huge step forward for the development of concurrent applications, with improvements to the Java Virtual Machine to support high-performance, highly scalable concurrent classes and a rich set of new concurrency building blocks. In Java Concurrency in Practice, the creators of these new facilities explain not only how they work and how to use them, but also the motivation and design patterns behind them. However, developing, testing, and debugging multithreaded programs can still be very difficult; it is all too easy to create concurrent programs that appear to work, but fail when it matters most: in production, under heavy load. Java Concurrency in Practice arms readers with both the theoretical underpinnings and concrete techniques for building reliable, scalable, maintainable concurrent applications. Rather than simply offering an inventory of concurrency APIs and mechanisms, it provides design rules, patterns, and mental models that make it easier to build concurrent programs that are both correct and performant.This book covers: *Basic concepts of concurrency and thread safety *Techniques for building and composing thread-safe classes *Using the concurrency building blocks in java.util.concurrent *Performance optimization dos and don’ts *Testing concurrent programs *Advanced topics such as atomic variables, nonblocking algorithms, and the Java Memory Model

Threads are a fundamental part of the Java platform. As multicore processors become the norm, using concurrency effectively becomes essential for building high-performance applications. Java SE 5 and 6 are a huge step forward for the development of concurrent applications, with improvements to the Java Virtual Machine to support high-performance, highly scalable concurrent classes and a rich set of new concurrency building blocks. In Java Concurrency in Practice, the creators of these new facilities explain not only how they work and how to use them, but also the motivation and design patterns behind them. However, developing, testing, and debugging multithreaded programs can still be very difficult; it is all too easy to create concurrent programs that appear to work, but fail when it matters most: in production, under heavy load. Java Concurrency in Practice arms readers with both the theoretical underpinnings and concrete techniques for building reliable, scalable, maintainable concurrent applications. Rather than simply offering an inventory of concurrency APIs and mechanisms, it provides design rules, patterns, and mental models that make it easier to build concurrent programs that are both correct and performant. This book covers:

• Basic concepts of concurrency and thread safety
• Techniques for building and composing thread-safe classes
• Using the concurrency building blocks in java.util.concurrent
• Performance optimization dos and don’ts
• Testing concurrent programs
• Advanced topics such as atomic variables, nonblocking algorithms, and the Java Memory Model

As processors become faster and multiprocessor systems become cheaper, the need to take advantage of multithreading in order to achieve full hardware resource utilization only increases the importance of being able to incorporate concurrency in a wide variety of application categories. For many developers, concurrency remains a mystery. Developing, testing, and debugging multithreaded programs is extremely difficult because concurrency hazards do not manifest themselves uniformly or reliably. This book is intended to be neither an introduction to concurrency (any threading chapter in an "intro" book does that) nor is it an encyclopedic reference of All Things Concurrency (that would be Doug Lea’s Concurrent Programming in Java). Instead, this title is a combination of concepts, guidelines, and examples intended to assist developers in the difficult process of understanding concurrency and its new tools in J2SE 5.0. Filled with contributions from Java gurus such as Josh Bloch, David Holmes, and Doug Lea, this book provides any Java programmers with the basic building blocks they need to gain a basic understanding of concurrency and its benefits.

you’re not threadsafe
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.

The definitive guide to concurrency with Java
Prior to this book, I spent many years trying to understand concurrency with Java, but I failed. During that time, I actually read four books.

When it comes to concurrency (thread safety and multi-threading), this book is a definitive guide. During the past two years, I have been constantly reading this book. I am still learning.

If you are not familiar with thread safety and Java memory model (as it was my case), you will probably struggle with the first chapters. But it is worth it!

I absolutely recommend this book.

This book build understanding in concurrency from ground up
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!

Superb book.
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.

Excellent primer for an oft overlooked and misunderstood topic
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.

The best book on Java concurrency out there.
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.

Excellent book for Java 1.5 Concurrency
This is a very nice book to get to know all the tools of Java 5 for concurrency support.

Best Java Concurrency Book -must read.
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.

awesome book on concurrency
An awesome book on concurrency that all Java programmers ought to read before embarking on anything more complicated than the primordial Hello World application.

Title should be: Java Thread Bible
After reading this book you will probably thank God that you haven’t been using threads, but with that being said this book contains all the information you need to start writing code that walks the straight and narrow path.

Authoritative on the subject
This is "the" authoritative book on java concurrency. However, apart from some java specific items, the book is an excellent source on parallelism in general. Do not even try to implement parallelism without "reading and understanding" this book. Highly recommended !!!

Good Book
This was a solid book to gaining an understanding of Java concurrency, especially the new concurrency features introduced in Java 1.5

Agree With Previous Viewer--Paper Quality Horrible!
Though the book is admittedly good and valuable in content, the paper quality of the pages is absolutely horrible! One can see through to the next page, and using a highlighter for emphasis is next to impossible. I will never buy this book as long as the paper quality is so poor (as my colleagues have also mentioned).

AWESOME book... but just a long, long read...
It’s a great book that everyone should read. You’ll definitely wind up stopping yourself from some common mistakes that result in the ever-so-common "WTF?!?!!?" reaction when debugging for a couple hours and seeing things working just fine, but not working on and off in production. Yeah... then it dawns on you that there’s a synchronization issue.

This book helps keep those kind of issues in mind much, much better.

The only downside to the book is that it’s a complete bear to read. It’s just an exceedingly difficult book to work yourself through. I actually finished two other books while reading it. It’s just really heavy without any real breaks in there to keep it entertaining.

Again... great book, but in a next revision I hope the authors take some time to just make it a bit of a lighter read.

A Must Have...
Another "A-List" Java book that needs to be in every Java reference library. "Java Concurrency in Practice" provides clear and concise coverage of a nontrivial subject.

Review for Java Concurrency in Practice
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.

Very Practical
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.

The last book that will ever be written on Java concurrency
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.

Remarkable book
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.

Simple clear advice on concurrency
Don’t think I can add much to the review of this title, it is simply one of the
best and clearest books on concurrency usage in Java applications.

Dissection on Java Concurrency
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.

now printed on POOR QUALITY PAPER
I’m sure the content is still superb. But the quality of the paper is pretty poor. The latest release of this paperback, 5th printing, July 2007, is printed on thin see-through recycled paper. I’m for preserving the environment, but I’m against paying full price for what seems like shoddy merchandise.

I tend not to buy international editions, precisely because the paper is so cheap that you can see right through it, making reading difficult. Sadly, this domestic edition suffers the same fate, albeit not as badly as some Low Priced Editions; it’s merely annoying. Truth be told, other domestic full priced editions also have translucent paper; but I still don’t like it, and the flimsy through-view paper in this book stands out.

Excellent explanation of a complex subject.
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.

The best Java Concurrency book out there
This is an excellent book on writing good thread-safe java code. It starts out with the concurrency basics, but gets into some more complex code design. Since multi-threaded applications and multi-processor boxes are becoming more and more common, this book is a must-read for every software developer.

Good Text, Lack of Details on Concurrent Package is a turn off
Simply put this book can be viewed from a love it or hate it perspective, but personally when i bought Java Generics and Collections ( O Reilly ) i was impressed by the depth of their coverage, it gave me that inside edge and the internal knowledge of generics and collections ( how they work etc. ) This Book works well in giving what to do, what could have been done better and some portions on Concurrent package, but simply put I AM NOT SATISFIED WITH ITS COVERAGE ON CONCURRENT PACKAGE!. if you stack up generics against this one, i’d say generics is 200% better than this one.

So yea i was a bit disappointed with the book. But hey, nothing works better than the Java Language Spec Third edition =). ( at least it gives you everything exhaustively ).

Regards
Vyas, Anirudh

Avoid those unrepeatable bugs!
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.

beginner-oriented
Good book, yet IMO it’s too "for beginners". Authors seem to explain things very slowly, perhaps it’s great for people with little programming experience, but I found the tempo a bit slow.
I think that Concurrent Programming in Java by Doug Lea is more appealing to experienced developer, unfortunately I don’t think there is a new edition out that covers Java 5. When/if new edition comes out, I’ll switch, but for now I’d stick with Java Concurrency in Practice.

Teaches clear thinking in thread programming
Perfectly lucid style combined with a number of architectural patterns makes this book a treasure. Totally love it.

Very useful book on an increasingly important topic
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.

Excellent
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.

Good textual Book
Goetz did a really nice nice job in putting together lots of issues on how to deal with concurrency in Java, not focusing only the util.concurrent/Java 5 API but how to make other aspects of the platform (such as frameworks, servlets and swing apps) to use them. The book is full of useful and detaild (although not boring) information and advice, using real examples.

Java Concurrency in Practice
I’m not a stranger to the java.util.concurrent package, but must admit that I learned and awful lot by reading this (really well written) book. But be warned: The more you know, the more you know you don’t know...

nice book
This is a nice book, with a great treatment of concurrency programming in Java. However, I would like to see a couple of "real" examples that uses the ideas discussed.

Excellent!
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.

This is a must have
I have only read first three chapters till now. But I can certainly say "This is a must have for all JAVA programmers.".

Exceptionally well written
I am already fairly experienced at writing concurrent applications and bought this just to get a reference to the new concurrency features of Java 1.5. However, its so well organised and written that I have been reading it from start to finish just for the pleasure of it.

excellent
This book is a must-read for anyone working in java with the shared-memory concurrency model. Ideas are very clearly exposed & the new java.util.concurrent package is explained perfectly.
If you work in java with threaded code, stop whatever you’re doing and read this book, now!

A great explanation of a little-understood topic
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.

Great for beginners on up
A great way to get your feet wet with Java concurrency. It also grows well and will take you pretty far on the way to mastery (I’ll let you know when I get there :).

You need this book
Terrific coverage of advanced thread topics. You’ll never look at your code the same way again. Great examples. Perfect balance between theory and practice.

Organized, thorough, and practical
This book is a tour de force. The subject matter is intrinsically difficult and frighteningly susceptible to detail. I knew I had gaps in my knowledge when I started to read it, but the extent of my ignorance was chilling.

The book chooses a very thoughtful level of abstraction which gives the reader the opportunity to absorb the essential problems and patterns without straying too far from the inconvenient realities, at the same time teaching a kind of framework for analysis of multithreading issues. It is a very well organized book that will serve as a fine reference after providing the initial learning experience. The book’s focus on the Java 5 concurrency library makes both the lessons and the library accessible and easy to exploit. The lessons are deep and varied and without exception practical.

Practising multithreaded programming in Java without reading this book is like doing aerials without a net. If you choose not to, good luck, and I hope it doesn’t hurt too much.

Top Notch, advanced, readable and SCARY


This is clearly one of the top notch Java books like Doug Lea’s original "Concurrent Programming in Java". And like CPIJ it is scary. Can one ever get the concurrency aspects right enough? Are the books of other authors trustworthy (enough)? There is so little help from the language itself and the IDEs to get things concurrency correct. And the authors show in many examples, what all can go wrong and that our old "Von Neumann machine" intuition is plainly wrong and often highly misleading. With the inevitable concurrency, Java is in fact a language for advanced programmers. Things will in practice get worse due to the increasing ubiquity of multiprocessor computers even on the desktop.


The book is written by leading Java experts. It cites and uses in an unusually extensive ways some of the other classics in our Java world:
Arnold et al. "The Java Programming Language",
Lea "Concurrent Programming in Java",
Gosling et al. "Java Language Specification" and
Bloch "Effective Java".
It is helpful but not mandatory to know them. Better it is to have them handy to be able to quickly look things up. Most other referenced works are original articles.


"Java Concurrency in Practice" is written in a readable style - though the material is presented in an unusual dense way for an Addison and Wesley Java book. Expect an information density more like an O’Reilly one, but a lot lower than a Springer one. Anyhow the book gets easier to read as you and your understanding progresses.


The presented material relies on and explains the new concurrency features of Java 5 and even Java 6. But it is not a tutorial of the new concurrency classes. It is a high level introduction from the usage pattern point of view. It explains the new classes only as far as is necessary.


One of my favorite chapters is on testing concurrent programs. Yes, it is possible to make unit tests for concurrent classes. No, it does not look like it is much fun though. But, you get a good head start. Besides peer review you also find some testing help in static analyzers like "findbugs".


In summary I recommend this book as one of the core Java books. I still wish the world is - with respect to multithreading - easier and less intimidating.

Top-notch
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.

Practical Java Concurrency for Java5/6
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.

Excellent comprehensive software book
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, that one is also an excellent "must read" material.

Must-read if you’re working with threaded Java applications...
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.

At last! A readable, expert book on Java concurrency
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.