Sign in with Facebook
Loading...
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.
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.
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 :)
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 :)
2 likes · like · see review
view 1 comment
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
This book is very good to read, examples are so accurate and well explained. For sure it is not a book for beginner.The subject is hard, so you need to really pay attention while reading.One has to read it many times.
This book should be required reading for anyone dealing with multithreaded Java programs. Besides being incredibly informative it's also very well written and a pleasure to read (at least by the standards of technical books).
A very thorough discussion on general concurrency topics even though the text is geared towards the Java.
So far so good. A little heavy but that's to be expected. One of those books you have to read and re-read.
It`s a good book, let me know more knowledge about java concurrency.
There are not many essential Java books, but this is one of them.
Çok güzel bir kitap.
amazing book :)
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?"
Great book, I recommend it to anybody who is doing any kind of threaded programming in java. It's good both to read straight through, and makes a great reference too.
This makes me very excited to check out Doug Lea's fork/join framework
This makes me very excited to check out Doug Lea's fork/join framework
If I mark more things that I should remember when coding up a program with threads there won't be much of the book left. Tons of tidbits explaining how to use Java's new concurrency libraries to write great code. On pg 224/354.
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).
It seems amazing I've ever written any thread-safe code! This book really explains the ins and outs of what may cause problems in a threaded environment.
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.
Anyone that even semi-seriously considers themselves a java programmer should have read this book, probably multiple times.
These books always remind me about all the things I'm doing wrong! I'll be referring to this book constantly!
I'm finding this to be an indispensable reference to concurrent programming in Java.
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…
