Java Concurrency in Practice
"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)
Friend Reviews
To see what your friends thought of this book,
please sign up.
This book is not yet featured on Listopia.
Add this book to your favorite list »
Community Reviews
(showing
1-30
of
996)
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...more
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...more
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
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...more
Java Concurrency in Practice is much more than a reference to programming libraries and would be useful...more
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...more
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...more
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.
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.
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.
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
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.
-m
-m
Extremely well written by a group of very smart people, but one of the major functions of the book is to point out how little Java has adapted to the multicore world as compared to languages like Erlang or Go. If you must work in Java and need to do concurrency the book is great, but if you really need concurrency you may want to ask, "Should I be using Java?"
Oct 04, 2009
Demian
added it
This book is great, Goetz is the man but ugh, it so hard getting through this. I'm shelving it for now in favor of Grails/ git/ Android.
May 24, 2013
Daniel Burrell
is currently reading it
May 24, 2013
Pom Pam
marked it as to-read
There are no discussion topics on this book yet.
Be the first to start one »
Goodreads is hiring!
Share This Book
No trivia or quizzes yet. Add some now »
“Whenever more than one thread accesses a given state variable, and one of them might write to it, they all must coordinate their access to it using synchronization.”
—
1 person liked it
“It is far easier to design a class to be thread-safe than to retrofit it for thread safety later.”
—
1 person liked it
More quotes…

Loading...


view 1 comment






















