Goodreads helps you keep track of books you want to read.
Start by marking “Java Concurrency in Practice” as Want to Read:
Java Concurrency in Practice
Enlarge cover
Rate this book
Clear rating
Open Preview

Java Concurrency in Practice

4.45  ·  Rating details ·  2,416 ratings  ·  118 reviews
"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 th ...more
Paperback, 403 pages
Published May 1st 2006 by Addison-Wesley Professional (first published May 19th 2005)
More Details... Edit Details

Friend Reviews

To see what your friends thought of this book, please sign up.

Community Reviews

Showing 1-30
Average rating 4.45  · 
Rating details
 ·  2,416 ratings  ·  118 reviews

More filters
Sort order
Start your review of Java Concurrency in Practice
Erika RS
Dec 28, 2012 rated it it was amazing
Shelves: software, physical, owned
Every programming language needs to have a book like Java Concurrency in Practice. I usually do not like books about specific programming languages because they tend to become obsolete so quickly. They are so specific to a particular version of a particular language that any small change renders them useless.

That is not the case with Java Concurrency in Practice. This book mixes general concurrency background and advice with Java specific advice with advice applicable to only certain versions of
Dec 30, 2008 rated it it was amazing
Recommends it for: Java programmers
Recommended to Michael by: Rich Hickey
Wow, this was a damn fine book. For anyone exposed to the pre-Java5 concurrency support (implicit locking and volatile) this is an eye-opener. Goetz and company systematically deconstruct a bevy of poorly constructed "concurrent" source and provide tips and approaches to simplify concurrency in Java. The #1 point to take from this book is to avoid mutable data structures at all costs. Easier said than done of course, but much easier than lock-based concurrency.

Michael Koltsov
Nov 01, 2013 rated it it was amazing
It was quiet easy to review this book, because i try to re-read it every year and it had became a necessity for me. Some parts of it are not easy to comprehend but at the end of the day this book can teach you what no other book could.

This time i’ve created a repository that contains most of the examples. In my experience writing code helps me much more than reading code.

My score 5/5
Algirdas Raščius
Jan 26, 2012 rated it it was amazing
Every Java developer should read this book.

There is a lot to learn from this book. And there is a lot of bad concurrent code written. World would be noticeably better, if every Java developer read this book before writing any concurrent code :)
May 15, 2019 rated it it was amazing
Before I read this book, I thought, I already understand concurrency. How much Java-specific stuff can there be to learn? If I want to use some library, e.g. ConcurrentHashMap, I'll read its documentation before I use it. That should be good enough.

I was wrong. Partly this is because I didn't actually understand concurrency as well as I thought. I was used to thinking in terms of interleavings and ignoring reordering, which is insufficient! This led to some big surprises when reading possible pr
Apr 15, 2010 rated it really liked it
Until I read this book, I was stuck on the early model of concurrent programming in Java. Basically, you had threads and you had synchronized methods. The performance characteristics of thread scheduling and lock acquisition were questionable in the early virtual machines, so I never bothered with them. The situation improved dramatically in Java 5, and Goetz et al. cover all the ins and outs.

Java Concurrency in Practice is much more than a reference to programming libraries and would be useful
Jul 20, 2014 rated it it was amazing
Well, I don't want to repeat what was already said, but "Java Concurrency in Practice" is the something like ABC for the Java developers. It covers all aspects of writing safe concurrent programs - from simple synchronization locking mechanisms, through higher level approaches, to nonblocking synchronizations, and some information about Java Memory Model. And what is more important - this book is still current, 8 years after its publication. Thank you Brain Goetz (and others) for time you have s ...more
Ian Nelson
Nov 25, 2011 rated it really liked it
This is an amazing book from both the software engineering and computer science perspectives. Having not learned much about concurrency from my degree program, and wanting to learn more, I turned to this book as a reference. There have been many reviews on this text, most positive, and I can definitely see why.

Although there is a *lot* of content to cover, it is very in-depth, and provides many examples to work through all of the conditions and failures that one may encounter.
May 23, 2012 rated it it was amazing
Shelves: programming
Anyone that even semi-seriously considers themselves a java programmer should have read this book, probably multiple times.
Feb 06, 2015 rated it really liked it
Book wonderfully covers ins and outs of concurrent programming in Java. Unfortunately, this book has won its renown due to one crucial factor - it one of the very few books covering this topic to such extent. Following this - the situation in which one-eyed is the king in the land of the blind is more than visual.

First and most definite problem with this book is the organisation of the material. To fully understand this book you have to read it at least twice. Why? Throughout the book the refere
Jack Repenning
This is a really crucial book for any Java developer. You may not realize you need it, but man oh man, you do![return][return]The Java culture and language development contain a trap: whereas it once was a commonplace that concurrent programming was too hard for "ordinary" developers, Java made it easy to do, and even in the beginning reasonably easy to do successfully.[return][return]Times have changed. Java programs used to run on uniprocessor machines (where "concurrency" is more an aspiratio ...more
Apr 08, 2010 rated it really liked it
I've actually read a significant portion of this already, but leaving it in my on-hold queue for now since I really want to finish all of it and revisit a few key parts. I can say that if you're doing anything concurrent on the JVM (and chances are that if you're doing anything on the JVM, you are), you should read this. It's a fantastic introduction to the mechanics of the system. Everything else you will find out there that presents alternate concurrency approaches (Akka, RxJava, etc.) builds ...more
Yaroslav Dremanovich
Aug 10, 2016 rated it it was amazing
It took too much time to read it .. but it contains many theoretical parts and helps to set your mind in thinking in multi threads realty.. So, you will know how to safe publish objects, persist correctness of your program and speed up your program if it applicable by hardware.. One needs to read it once (no more). Despite that the book issued in 2006 - it is still actual in terms of manual handle of synchronization.
As for today - better way to improve performance of your code is to use JavaRx s
Jevgeni Holodkov
Oct 01, 2011 rated it it was amazing
The book is definitely worth reading even if you do only develop enterprise applications, which get most of the concurrency from the application servers (at least will you understand how it works). You will get a deep understanding how does java.util.concurrent api works, why it is needed and when to apply one or another technique. The book is full of examples, guiding a reader from "bad" solutions to "better" and "best" solutions. Concurrency idioms are very well covered. I gave this book 5 sta ...more
Sep 07, 2011 rated it really liked it
As far as books on key programming topics go, this one is a gem. Insightful, relevant, and well written, serious Java developers ought to check this one out. Many of stickiest programming issues relate to threading or concurrency issues, and this book really comes through in outlining common mistakes, and offering great tips and solutions for the most common types of threading/asynchronous issues that tend to plague us.
Jan 07, 2017 rated it really liked it
Very well done. Full of useful information, suggestions, and examples. I bought it for a specific question, found the answer right away and it was perfect! I could have tried much more complicated things, but this provided a simple solution that saved me a lot of time. I did not read it cover to cover.
Emil Petkov
Dec 30, 2012 rated it it was amazing
Brian Goetz is a concurrency czar - this gem taught me a lot about multicore development, non-blocking algorithms, threads, etc. The book is so deep and yet so practical that most of the other pieces on threading/concurrency seem like part of the "For Dummies" series.
Kenneth Blomqvist
Jul 09, 2016 rated it it was amazing
Goes into all the details of concurrent programming and explains the Java memory model and it's guarantees.

Highly recommended to any developer writing concurrent software (even if you don't use Java).
Martin Asenov
Jul 10, 2012 rated it it was amazing
Java concurrency in practice is one of the best programming-related books I have ever read (perhaps along with Effective Java, Java Puzzlers and Martin Fowler's refactoring).
Irakli Kobiashvili
May 26, 2014 rated it it was amazing
Shelves: favorites
The very best book about this topic. I learned lot from this book - thanks to authors.
Jan 03, 2015 rated it it was amazing
Shelves: technology
Must read for every java programmer
Andrew Barchuk
May 21, 2015 rated it it was amazing
Very solid book despite not covering some more recent topics like fork-join concurrency, parallel Java 8 streams and RxJava.
Jan 11, 2016 rated it it was amazing
I've heard this book referenced countless times in my career but never bothered to read it because I wasn't writing Java. Now I wish I had read it sooner.
Apr 18, 2018 rated it it was amazing
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
Jan 04, 2020 rated it it was amazing
One of the few must read books for anbody writing Java for a living.
Before this books I was only vaguely aware of the pitfalls with concurrency in Java. The first part of the book "Fundamentals" helped me understand the concepts involved and put my reasoning about concurrent code on a more solid foundation.
The second part of the book are about structuring using the executor framework, which is also interesting if you have never work with it before.
But for me the real value came from the first
Madhur Bhargava
Feb 26, 2019 rated it it was amazing
Shelves: programmming
This book is the final word on threading and concurrency in Java. I always thought concurrency was a bit tricky but this book really takes it to the next level. The author provides a thorough explanations of the under the hood workings of Java Concurrency & the JMM. Some of the explanations in the book can stump even the expert Java programmers with several 'Aha' moments. I specifically enjoyed the last chapter which highlights the main points of JSR 133 & JMM. Truly a must read for any serious ...more
Mar 19, 2020 rated it really liked it  ·  review of another edition
Shelves: on-kindle
(4.5) Good to have read once, more detail than can be absorbed in one go, probably good reference but we’ll see

Remains to be seen whether this will be useful as reference for a specific scenario or question I run into, but I’m optimistic. Haven’t written multi-threaded Java in a looooooong time and much has changed, and this really helped me to catch up. So much less wild-west, which feels comforting.

I do wonder how much of this is true/applicable now, but soon will not be (even if we stick with
Isidro López
Jan 05, 2019 rated it really liked it
This was my third attempt in the last 10 years to read it... and finally succeeded, yuhuu :-D

It's that kind of book where you think: "How have I been able to work without reading it?" ^___^

I feel that even in 2019 it brings a lot of value, many things still apply.

On the other hand, is far away from a beginner-intermediate book, I would only recommend it to people who have been working with Java for several years.
Viraj Bhosle
Jul 13, 2019 rated it it was amazing
Shelves: java
Must for understanding Java multi-threading. Java Concurrency in Practice explains multi-threading clearly with examples. It show how we can build complex and robust multi-threading code by using simple building blocks. This books gave me confidence to write concurrent code, enlightened me about all the pitfalls.
Jan 19, 2019 rated it it was amazing
One of the best books about concurrency in Java. It explains in a really clear way the whole concepts about this dense topic. It is full of code examples and, if you want to understand how to manage the concurrency in Java in a low level, you have to read it.

Recommended 100%
« previous 1 3 4 next »

Readers also enjoyed

  • Effective Java
  • Design Patterns: Elements of Reusable Object-Oriented Software
  • Head First Design Patterns
  • Refactoring: Improving the Design of Existing Code
  • Clean Code: A Handbook of Agile Software Craftsmanship
  • Designing Data-Intensive Applications
  • Patterns of Enterprise Application Architecture
  • Building Microservices: Designing Fine-Grained Systems
  • Cracking the Coding Interview: 150 Programming Questions and Solutions
  • Thinking in Java
  • The Clean Coder: A Code of Conduct for Professional Programmers
  • Domain-Driven Design: Tackling Complexity in the Heart of Software
  • The Mythical Man-Month: Essays on Software Engineering
  • The Pragmatic Programmer: From Journeyman to Master
  • Spring in Action
  • Introduction to Algorithms
  • Growing Object-Oriented Software, Guided by Tests
  • Programming in Scala
See similar books…

Goodreads is hiring!

If you like books and love to build cool products, we may be looking for you.
Learn more »

News & Interviews

Need another excuse to treat yourself to a new book this week? We've got you covered with the buzziest new releases of the day. To create our lis...
5 likes · 0 comments
“It is far easier to design a class to be thread-safe than to retrofit it for thread safety later.” 12 likes
“Just as it is a good practice to make all fields private unless they need greater visibility, it is a good practice to make all fields final unless they need to be mutable.” 11 likes
More quotes…