This site uses cookies to deliver our services, improve performance, for analytics, and (if not signed in) for advertising. By using LibraryThing you acknowledge that you have read and understand our Terms of Service and Privacy Policy. Your use of the site and services is subject to these policies and terms.
Hide this

Results from Google Books

Click on a thumbnail to go to Google Books.

Java Concurrency in Practice by Brian Goetz

Java Concurrency in Practice (original 2006; edition 2006)

by Brian Goetz, Tim Peierls, Joshua Bloch, Joseph Bowbeer, David Holmes1 more, Doug Lea

MembersReviewsPopularityAverage ratingConversations
393242,688 (4.26)None
"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 this book." --Martin Buchholz JDK Concurrency Czar, Sun Microsystems "For the past 30 years, computer performance has been driven by Moore''s Law; from now on, it will be driven by Amdahl''s Law. Writing code that effectively exploits multiple processors can be very challenging. Java Concurrency in Practice provides you with the concepts and techniques needed to write safe and scalable Java programs for today''s--and tomorrow''s--systems." --Doron Rajwan Research Scientist, Intel Corp "This is the book you need if you''re writing--or designing, or debugging, or maintaining, or contemplating--multithreaded Java programs. If you''ve ever had to synchronize a method and you weren''t sure why, you owe it to yourself and your users to read this book, cover to cover." --Ted Neward Author of Effective Enterprise Java "Brian addresses the fundamental issues and complexities of concurrency with uncommon clarity. This book is a must-read for anyone who uses threads and cares about performance." --Kirk Pepperdine CTO, JavaPerformanceTuning.com "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." --Dr. Cliff Click Senior Software Engineer, Azul Systems "I have a strong interest in concurrency, and have probably written more thread deadlocks and made more synchronization mistakes than most programmers. Brian''s book is the most readable on the topic of threading and concurrency in Java, and deals with this difficult subject with a wonderful hands-on approach. This is a book I am recommending to all my readers of The Java Specialists'' Newsletter, because it is interesting, useful, and relevant to the problems facing Java developers today." --Dr. Heinz Kabutz The Java Specialists'' Newsletter "I''ve focused a career on simplifying simple problems, but this book ambitiously and effectively works to simplify a complex but critical subject: concurrency. Java Concurrency in Practice is revolutionary in its approach, smooth and easy in style, and timely in its delivery--it''s destined to be a very important book." --Bruce Tate Author of Beyond Java " Java Concurrency in Practice is an invaluable compilation of threading know-how for Java developers. I found reading this book intellectually exciting, in part because it is an excellent introduction to Java''s concurrency API, but mostly because it captures in a thorough and accessible way expert knowledge on threading not easily found elsewhere." --Bill Venners Author of Inside the Java Virtual Machine 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 classes and a rich set of new concurrency building blocks. In Java Concurrency in Practice , the creators of these new facilities explain not only how they work and how to use them, but also the motivation and design patterns behind them. However, developing, testing, and debugging multithreaded programs can still be very difficult; it is all too easy to create concurrent programs that appear to work, but fail when it matters most: in production, under heavy load. Java Concurrency in Practice arms readers with both the theoretical underpinnings and concrete techniques for building reliable, scalable, maintainable concurrent applications. Rather than simply offering an inventory of concurrency APIs and mechanisms, it provides design rules, patterns, and mental models that make it easier to build concurrent programs that are both correct and performant. This book covers: Basic concepts of concurrency and thread safety Techniques for building and composing thread-safe classes Using the concurrency building blocks in java.util.concurrent Performance optimization dos and don''ts Testing concurrent programs Advanced topics such as atomic variables, nonblocking algorithms, and the Java Memory Model… (more)
Title:Java Concurrency in Practice
Authors:Brian Goetz
Other authors:Tim Peierls, Joshua Bloch, Joseph Bowbeer, David Holmes, Doug Lea
Info:Addison-Wesley Professional (2006), Paperback, 384 pages
Collections:Your library

Work details

Java Concurrency in Practice by Brian Goetz (2006)

Recently added byprivate library, DIWalker1960, tideworks, banjiewen, libib479, xrtrading

Sign up for LibraryThing to find out whether you'll like this book.

No current Talk conversations about this book.

Showing 2 of 2
well very good ,it is that i find ( )
  qinchange | May 12, 2014 |
This is a really crucial book for any Java developer. You may not realize you need it, but man oh man, you do!

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.

Times have changed. Java programs used to run on uniprocessor machines (where "concurrency" is more an aspiration than a reality), and the Java virtual machine used to be relatively simple. Nowadays, even an inexpensive laptop has at least two cores, and can achieve real concurrency among half a dozen Java threads. The JVM has evolved aggressively to use this power, taking liberal advantage of feature always contained in the Java language specifications, but until now not necessary embodied in the JVM implementation. As a result, more and more, your programs do not mean what they appear to mean, and less and less are you free to presume they do.Fortunately, the principal and supporting authors here are the powerful minds behind the growth of the JVM's concurrency capabilities. And, a bit miraculously, these great minds, deeply embedded in this complex code, can and do explain its surprises and mastery in a way that should be accessible to any competent programmer. This is not "for Dummies" stuff, but it's also "not rocket science" (quite). You can handle this.

And, you must. ( )
  jrep | Dec 22, 2010 |
Showing 2 of 2
no reviews | add a review
You must log in to edit Common Knowledge data.
For more help see the Common Knowledge help page.
Series (with order)
Canonical title
Original title
Alternative titles
Original publication date
Important places
Important events
Related movies
Awards and honors
To Jessica
First words
At this writing, multicore processors are just becoming inexpensive enough for midrange desktop systems.
Last words
Disambiguation notice
Publisher's editors
Publisher series
Original language
Canonical DDC/MDS

No library descriptions found.

Book description
Haiku summary

Quick Links

Popular covers


Average: (4.26)
1 2
2 1
3 4
4 15
4.5 6
5 22

Is this you?

Become a LibraryThing Author.


About | Contact | Privacy/Terms | Help/FAQs | Blog | Store | APIs | TinyCat | Legacy Libraries | Early Reviewers | Common Knowledge | 139,556,799 books! | Top bar: Always visible