Concurrent Programming in Java(tm): Design Principles and Pattern

by Doug Lea and Douglas Lea

Book Overview

One of Java's most powerful capabilities is its built-in support for concurrent programming, a design technique in which multiple concurrent activities-threads take place inside a single Java program. Thread programming enables developers to design applications that are more responsive to user demands, faster, and more easily controlled. This book offers comprehensive coverage of this vital aspect of the Java language. The book is completely...

• Format: Paperback
• Language: English
• ISBN: 0201310090
• ISBN13: 9780201310092
• Release Date: October 1999
• Publisher: Addison-Wesley Professional
• Length: 432 Pages
• Weight: 1.50 lbs.
• Dimensions: 0.8" x 7.3" x 9.3"

Customer Reviews

Everything you need to know about concurrency in Java

Concurrent programming is fraught with peril. It's much more complex than sequential programming in every meaningful way from specification to unit testing. But if you want to do it right, meaning balancing liveness with safety for efficient and robust multi-threaded applications, you need Doug Lea's "Concurrent Programming in Java". Especially if you need to design an extensible framework with concurrency; well-known examples of such frameworks incluce Swing, most of java.net, and just about every aspect of J2EE.Lea provides an intense introduction at the level of an advanced undergraduate course. It's fairly academic in tone, because he takes the time to provide thorough definitions and detailed examples. As a former academic who now designs and programs for a living, this is just what I was looking for. But don't buy this book expecting a cookbook of code to cut and paste. It's much more about providing you the fundamental tools to design your own concurrent classes, applications and frameworks. Lea presupposes the user is fluent in Java, knows a bit about concurrent programming patterns involving mutexes, semaphores, etc, and is familiar with the basic object-oriented design patterns. If you're not up to speed in these areas, the path I followed was reading the following:* Lewis's "Threads Primer" (warning: it's C/unix-based), * Gosling and Joy's "Java Programming Language",* Bloch's "Effective Java", and * Gamma et al.'s "Design Patterns".Even if you don't buy this book, consider using Lea's concurrent.util package available from his web site. It provides solid implementations of everything from simple mutexes to concurrent read-single write wrappers for Java collections (Sun's own wrappers simply synchronize all methods, which suffers reduced liveness compared to CRSW designs). And it's both elegantly designed and thoroughly javadoc-ed. The first edition was great, and I've just finished reading the second edition cover to cover and it has taken my understanding of concurrent design to a new level. Just be warned that this book's not for novices or hobbyists; it's for programmers who need to design the guts of concurrent systems the "right" way and then implement them in Java, especially for extensible frameworks.

Outstanding

This is unquestionably the best text on concurrent and multi-threaded programming in Java. If you or your team are writing multithreaded software in Java (and this includes awt and swing applications as well as server side), you simply must take the time to study this book. CPJ matters just as much as the JLS or the JPL and you will be rewarded many times over for the investment. Newcomers to Java concurrent programming may want to start with Kramer & Magee's book first. Understanding Java concurrency requires one tostep outside the language proper: it's neccessary to stop pretendingthat Java is platform independent in order to write reliablemulti-threaded code. You will have to understand the Java memorymodel, how OSes manage threads natively and you will have to make theeffort to grasp some difficult material...

A must-read for serious programmers

Concurrency is difficult to get right. If you're going to be doing concurrent programming - in any language, really - then you should have this book in your toolchest. Even if you've been doing multi-threaded programming for years, CPJ is likely to make you better at it. The book represents the latest thinking and advances in concurrency, and judging from the increase in scope over the first edition, it would appear that the state of the art is evolving rapidly.The second edition is a big improvement over the first: it's better-organized, better-written, and covers much more ground. It also has better treatment of Mr. Lea's "util.concurrent" package, a set of useful synchronization classes that will undoubtedly find their way into the Java platform at some point.This is a hard book to read, which is undoubtedly why it gets so many negative reviews from confused readers. You can't just browse through it in an hour and then expect to be able to write a multi-threaded web server. It covers enough material to fill a grad-level course in CS, and it helps to have a CS degree or the equivalent to get the most out of it. There are probably much better books out there if you want to get "up and running" with threads quickly. If you ever hope to do anything reasonably complex with threading, though, you should get this book and study it carefully.

Sets new standards in the world of IT literature.

Yes, this material is tough, but this is because concurrency is a tough subject. Folks who don't realize this have usually been fooled by the deceptive ease with which one can create, start and synchronize threads in Java.The author presents the principles of concurrency in a structured and lucid manner. He presents patterns which have proven successful in concurrent applications, and at the same time exploits patterns to the full as a means to communicate the concepts.The new information which has been added concerning the memory model, cancellation and portability are welcome additions to the first edition.Indeed, from cover to cover, the contents of this IT masterclass are *juicy* to say the least!

Excellent

Simply a great book on concurrent programming in Java. This book and the class library the author provides are an awesome combination. While some of the information is Java specific, this book is much more about concurrent programming in general.The author explains the primitive concurrency mechanisms provided in Java, such as Threads and Monitors, and then quickly moves on to higher level abstractions that embody many of the patterns found in multi-threaded applications. By encapsulating these, sometimes complex, patterns in reusable classes, the author shows how to maintain the separation of concerns between the concurrent aspects of the code and the logic of the task at hand.This book contains a thorough discussion of the topic and extensive code - both examples and a reusable class library. This is a must read for every Java developer.