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.41  ·  Rating Details  ·  1,475 Ratings  ·  74 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 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 for Dummies Quick Reference by Doug Lowe
3rd out of 19 books — 9 voters
Gödel, Escher, Bach by Douglas R. HofstadterThe C Programming Language by Brian W. KernighanDesign Patterns by Erich GammaThe Mythical Man-Month by Frederick P. Brooks Jr.Refactoring by Martin Fowler
Best Nonfiction Computer Science Books on Goodreads
42nd out of 80 books — 6 voters

More lists with this book...

Community Reviews

(showing 1-30 of 3,000)
filter  |  sort: default (?)  |  Rating Details
Erika RS
Dec 28, 2012 Erika RS rated it it was amazing
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
Jan 26, 2012 Algirdas Raščius 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 :)
Apr 15, 2010 Will 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
Aug 20, 2014 Szymon 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 Ian Nelson 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.
Apr 28, 2010 Michael 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
Dec 11, 2014 Michael Koltsov 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
Nov 16, 2012 Paul 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.
Jun 03, 2015 Marcin 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
Kenneth Blomqvist
Jul 17, 2016 Kenneth Blomqvist 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).
Jevgeni Holodkov
Nov 07, 2011 Jevgeni Holodkov 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
Nov 04, 2015 Nick rated it really liked it
Shelves: programming
Holy fucking shit. Reading Java: Concurrency in Practice has made me realize that probably every fucking program I’ve ever written is wrong, the world is constantly on fire, and you can’t have people writing reasonable applications with these barbaric and primitive tools.

Rich Hickey was a motherfucking genius. Functional programming languages and immutability almost everywhere are the only answers to any of this. Motherfucking semaphores and locks and synchronized blocks: are you kidding me? We
Emil Petkov
Dec 30, 2012 Emil Petkov 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.
Martin Asenov
Sep 26, 2012 Martin Asenov 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 Irakli Kobiashvili rated it it was amazing
Shelves: favorites
The very best book about this topic. I learned lot from this book - thanks to authors.
Jul 13, 2016 Andrew rated it really liked it
Very solid book despite not covering some more recent topics like fork-join concurrency, parallel Java 8 streams and RxJava.
Mar 03, 2016 Vitalijs rated it liked it
Picked up the book on recommendation. Though as Java is not my "main", I wanted to get from the book the concepts and ideas, which it does deliver, but reflective of the title the book tries to bind all the "concurrency done right" ideas to being executed in Java. I think this is a really good read for Java developers, but one would enjoy the book more with previous exposure to concurrency in Java. Can't say this is the to go book to learn concurrency (in Java), however it definitely would make ...more
Franck Chauvel
Apr 22, 2016 Franck Chauvel rated it really liked it
This book describes the in and out of multi-threaded applications in Java.

I like very much the way the authors define thread safe applications as those that preserve invariants, pre/post-conditions when accessed by multiple threads. Although I read similar ideas in Object-Oriented Software Construction, I found it much more concrete here.

The guidances to design thread safe classes and applications goes beyond the mere use of Java and applies to any programming language. Eventually, this is abou
Jan 03, 2015 Nitin rated it it was amazing
Shelves: technology
Must read for every java programmer
Jun 06, 2012 rated it it was amazing
Çok güzel bir kitap.
Marcio Endo
Apr 23, 2016 Marcio Endo rated it it was amazing
Programação concorrente é difícil. Talvez por este motivo apenas agora, uns bons 4 ou 5 anos após ter comprado o livro, resolvi lê-lo.

Não só difícil. Diria complexa. Cada vez mais, porém (e já há algum tempo), inevitável. Isto porque, chegado ao limite da Lei de Moore, estaremos sendo (cada vez mais) regidos pela Lei de Amdahl.

Se por um lado é mais do que correto afirmar que uma grande parte dos programadores poderá passar sua vida profissional inteira sem ter a necessidade de escrever uma únic
Cody Ray
Jan 22, 2014 Cody Ray rated it it was amazing
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
Aug 18, 2012 gargamelscat rated it it was amazing
Shelves: compsci, 2012
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
Apr 03, 2015 Ed Burns rated it really liked it
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.
Nov 10, 2014 Jeffrey rated it it was amazing
Shelves: programming
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!
Dec 06, 2014 Larry rated it liked 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
Jul 09, 2014 Rohit Vaidya rated it it was amazing  ·  review of another edition
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 it was amazing
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
Nov 26, 2014 Anatoliy Kaverin rated it it was amazing
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!
« previous 1 3 4 5 6 7 8 9 99 100 next »
  • Effective Java Programming Language Guide
  • Programming in Scala
  • Java Generics and Collections
  • Java Performance
  • Spring in Action
  • Thinking in Java
  • Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions
  • Programming Clojure
  • The Joy of Clojure
  • Concurrent Programming in Java: Design Principles and Pattern
  • The Art of Multiprocessor Programming
  • Programming Concurrency on the JVM
  • Patterns of Enterprise Application Architecture
  • Domain-Driven Design: Tackling Complexity in the Heart of Software
  • Growing Object-Oriented Software, Guided by Tests
  • Programming Erlang
  • Seven Languages in Seven Weeks
  • Purely Functional Data Structures

Goodreads is hiring!

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

Share This Book

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