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.4 of 5 stars 4.40  ·  rating details  ·  1,098 ratings  ·  56 reviews
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 ...more
Paperback, 403 pages
Published May 1st 2006 by Addison-Wesley Professional (first published 2006)
more details... edit details

Friend Reviews

To see what your friends thought of this book, please sign up.
Effective Java Programming Language Guide by Joshua BlochThinking in Java by Bruce EckelJava Concurrency in Practice by Brian GoetzJava Cookbook by Ian F. DarwinJava in a Nutshell by David Flanagan
3rd out of 19 books — 7 voters
Single Page Web Applications by Michael S. MikowskiJava for Dummies Quick Reference by Doug LoweSCJP Sun Certified Programmer for Java 6 Study Guide by Kathy SierraJava Concurrency in Practice by Brian GoetzJavaScript Objects Functions and Arrays Explained by Tony de Araujo
Web Development with HTML5 and Java
1st out of 42 books — 5 voters

More lists with this book...

Community Reviews

(showing 1-30 of 2,764)
filter  |  sort: default (?)  |  rating details
Erika RS
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
Algirdas Raščius
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 :)
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
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
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.
Apr 28, 2010 Michael rated it 5 of 5 stars
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.

Anyone that even semi-seriously considers themselves a java programmer should have read this book, probably multiple times.
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
Jevgeni Holodkov
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
Emil Petkov
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.
Irakli Kobiashvili
The very best book about this topic. I learned lot from this book - thanks to authors.
Cody Ray
Great overview of Java concurrency.

This text starts from the very basics of what is thread safety and atomicity and locking. It covers some of the theoretical aspects such as visibility and safe publication and the java memory model (which is addressed full-on only in the last chapter, relegating the early chapters to the implications and rules of thumb derived from the JMM). This sets the stage well to introduce a number of common problems and design patterns, such as data races and the lazy in
Someone looking for a good book on multithreading might be tempted to steer clear of this because of the word 'Java' in the title.

That would be unfortunate because the Java aspect is very much the minor chord in this exceptional symphony of a book. Using examples small enough to be comprehensible it engages with the many threading-related issues inherent in concurrency with a clarity and authority it is hard to find elsewhere.

Concurrency isn't just an extension of the sequential programming mode
Ed Burns
This book is an example of a dying breed of technical book: the topical complete reference. It does a great job of telling you everything you need to know about the topic of Java Concurrency. If you read and understand it from cover to cover, you will have been exposed to the breadth of the problem space, with a fair amount of depth as well. If you take the time to explore and execute the code samples, you get the necessary depth.
The book covers advanced aspects about concurrency in java. It has very technical and detailed explanations about the concurrency api. Was nice how it covers the old api, locking everything, then using synchronized collections and finally going to the concurrent collections.

But unfortunately it is not even a little bit didactic. So it is better to have a really good background in concurrency before this book.
I avoided reading this book for many years because I was not dealing with Concurrency issues in my day-to-day work. That was a mistake. The first section of this book is one of the most important, and easy to understand, explanations about designing software that I have ever read.

If you only make it through chapter 3, this book will still be worth 20x what you paid for it!
I'm cheating slightly here as the final chapter was so far over my head I just found it impenetrable. So I didn't 100% finish this book.

This is basically the indispensable reference and how-to book for working with concurrency in Java. It's an increasingly important topic in the last 10 years as CPU speeds have maxed out due to issues having to do with heat dissipation, which has steered CPU designers into multi-core architectures. To get the most out of more that 2 cores or so, you need to do c
Rohit Vaidya
This is fantastic read. Reading this book is painting the wall. Paint once. Do another round to commit it. Read it again and again and it will be a value addition for sure.
The author has handled concurrency with really verbose and simple examples. I am still reading it and going slow. But I am loving every bit of it.
Narendra Pathai
Oct 24, 2014 Narendra Pathai rated it 5 of 5 stars
Recommends it for: java developers
Shelves: software
This book can be appreciated at many levels. I have read it thrice and everytime I read it I learn something new. This is a highly in depth book about Concurrency and should only be approached when one is good with basic concepts of Threading.
Anatoliy Kaverin
This is a must-read book for every Java engineer working with multithreading.
It gives a lot of details on JMM and side-affect issues to consider.
One of the most useful books you find ever for Java engineering!
[4.5 stars]

There's a reason this book is a classic. It's a great read to break a lot of the bad intuitions I have around multithreading and other concurrency issues, and provides a lot more areas where I realized I had to think harder about cases I thought were innocuous. Plus it does a great job of delving deeper into how the JDK operates around some of these constructs, and how it interacts with both the memory model and the processor and OS themselves. Highly recommended if you are likely to
Rakesh Cherukuri
Solid read for advanced java programmers who want to dive into concurrency. Also, a good/must read for people who want to taste what lies in the concurrency utilities in JDK.
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
Great way to gain a ton of expertise in concurrency generally and the tools available in java specifically.
Ivan Ivic
Brian Goetz is a brilliant writer and even better speaker. I recommend watching this video from recent ClojureCon to any Java-skeptic (like I am): It succinctly explains why Java will continue to be relevant in the future and why it isn't moving forward as fast as some people would probably like.

As for this book, there is not much to tell. It's one of the Holy Books of Java (and programming in general). As Rich Hickey, creator of Clojure, has said himself
Must read for every java programmer
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.
Sep 11, 2013 Atul rated it 4 of 5 stars
Shelves: tech
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.
Michael Koltsov
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
« previous 1 3 4 5 6 7 8 9 92 93 next »
  • Effective Java Programming Language Guide
  • Programming in Scala
  • Spring in Action
  • Java Performance
  • Thinking in Java
  • Java Generics and Collections
  • Programming Clojure
  • Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions
  • The Joy of Clojure
  • Patterns of Enterprise Application Architecture
  • Concurrent Programming in Java: Design Principles and Pattern
  • Programming Erlang
  • Growing Object-Oriented Software, Guided by Tests
  • Domain-Driven Design: Tackling Complexity in the Heart of Software
  • Seven Languages in Seven Weeks
  • Purely Functional Data Structures
  • Working Effectively with Legacy Code
  • Agile Software Development, Principles, Patterns, and Practices

Goodreads is hiring!

If you like books and love to build cool products, we may be looking for you.
Learn more »
The Adventure of Two Lifetimes: A Mother/Daughter Journey Across America- And Time Java Concurrency in Practice [JAVA CONCURRENCY IN PRAC -OS] Basic Mathematics Jaba Heikō Shori Puroguramingu: Sono Kiban To Saishin Eipīai O Kiwameru Java Concurrency In Practice

Share This Book

“It is far easier to design a class to be thread-safe than to retrofit it for thread safety later.” 7 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.” 6 likes
More quotes…