Programming Books C Java PHP Python Learn more Browse Programming Books
Qty:1
  • List Price: $74.99
  • Save: $25.26 (34%)
Only 9 left in stock (more on the way).
Ships from and sold by Amazon.com.
Gift-wrap available.
Add to Cart
Condition: Used: Good
Comment: used copy with general use wear, intact, fast shipping
Access codes and supplements are not guaranteed with used items.
Add to Cart
Trade in your item
Get a $2.00
Gift Card.
Have one to sell? Sell on Amazon
Flip to back Flip to front
Listen Playing... Paused   You're listening to a sample of the Audible audio edition.
Learn more
See this image

Concurrent Programming in Java™: Design Principles and Pattern, 2nd Edition Paperback – November 4, 1999

ISBN-13: 078-5342310092 ISBN-10: 0201310090 Edition: 2nd

Buy New
Price: $49.73
30 New from $33.96 35 Used from $3.98
Amazon Price New from Used from
Paperback
"Please retry"
$49.73
$33.96 $3.98
Unknown Binding
"Please retry"
$94.99

Free%20Two-Day%20Shipping%20for%20College%20Students%20with%20Amazon%20Student




Frequently Bought Together

Concurrent Programming in Java™: Design Principles and Pattern, 2nd Edition + Java Concurrency in Practice + Effective Java (2nd Edition)
Price for all three: $130.04

Buy the selected items together

Customers Who Bought This Item Also Bought

NO_CONTENT_IN_FEATURE

Save up to 90% on Textbooks
Rent textbooks, buy textbooks, or get up to 80% back when you sell us your books. Shop Now

Product Details

  • Paperback: 432 pages
  • Publisher: Addison-Wesley Professional; 2 edition (November 4, 1999)
  • Language: English
  • ISBN-10: 0201310090
  • ISBN-13: 978-0201310092
  • Product Dimensions: 0.8 x 7.2 x 9.2 inches
  • Shipping Weight: 1.6 pounds (View shipping rates and policies)
  • Average Customer Review: 3.9 out of 5 stars  See all reviews (34 customer reviews)
  • Amazon Best Sellers Rank: #119,710 in Books (See Top 100 in Books)

Editorial Reviews

Amazon.com Review

Concurrent Programming in Java, 2nd Edition surveys a wide field of research in parallelism and concurrency and shows how to do more with multithreading in Java with dozens of patterns and design tips. Written for the advanced Java developer, this book offers a comprehensive tour of leading-edge thinking about parallel coding processes.

Within the dozens of techniques and tips offered here, this book accomplishes at least two goals. First, it shows how concurrency is implemented by default within Java, with material on how built-in features (like the synchronized keyword and its memory model) can be expected to perform when dealing with multiple threads. Naturally, Java threads themselves are also covered, including priorities, scheduling, and the like.

Much of this book looks at ways to improve performance of concurrent code beyond the simple default strategies. After defining criteria for measuring concurrent code (such as safety and "liveness," a measure of running live threads effectively), the book presents dozens of techniques for letting threads work together safely. For the working Java programmer, coverage of patterns that have been implemented in the downloadable java.concurrency package will be the most immediately useful. (Within this nearly encyclopedic survey, short code snippets are used for every pattern and concept.)

Though theoretical at times, this book offers plenty of ideas and sample code to get you started thinking of ways to improve multithreaded code.

Impressively comprehensive, Concurrent Programming in Java offers a veritable bible of techniques for doing two things at once with threads in Java. It's a worthwhile guide to the state-of-the-art strategies for improving the performance of your Java threads. --Richard Dragan

Topics covered: Threads and concurrency in Java, design considerations (safety, liveness, and performance), Before/After Patterns, layering, adapters, immutability and synchronization, deadlock, resource ordering, the Java Memory Model and concurrency, using the java.concurrency package, confinement, refactoring for concurrency, mutexes, read-write locks, recovering from failure, notifications, semaphores, latches, exchanges, transactions, one-way messages, worker threads, polling and event-driven I/O, parallelism techniques (fork/join, computation trees, and barriers), Communicating Sequential Processes (CSP).

From the Back Cover

In this second edition, you will find thoroughly updated coverage of the Javao 2 platform and new or expanded coverage of:

  • Memory model
  • Cancellation
  • Portable parallel programming
  • Utility classes for concurrency control

The Java platform provides a broad and powerful set of APIs, tools, and technologies. One of its most powerful capabilities is the built-in support for threads. This makes concurrent programming an attractive yet challenging option for programmers using the Java programming language.

This book shows readers how to use the Java platform's threading model more precisely by helping them to understand the patterns and tradeoffs associated with concurrent programming.

You will learn how to initiate, control, and coordinate concurrent activities using the class java.lang.Thread, the keywords synchronized and volatile, and the methods wait, notify, and notifyAll. In addition, you will find detailed coverage of all aspects of concurrent programming, including such topics as confinement and synchronization, deadlocks and conflicts, state-dependent action control, asynchronous message passing and control flow, coordinated interaction, and structuring web-based and computational services.

The book targets intermediate to advanced programmers interested in mastering the complexities of concurrent programming. Taking a design pattern approach, the book offers standard design techniques for creating and implementing components that solve common concurrent programming challenges. The numerous code examples throughout help clarify the subtleties of the concurrent programming concepts discussed.



0201310090B04062001

Customer Reviews

3.9 out of 5 stars
Share your thoughts with other customers

Most Helpful Customer Reviews

32 of 32 people found the following review helpful By Eric A. Snell on January 30, 2000
Format: Paperback
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.
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
26 of 27 people found the following review helpful By Bob Carpenter on April 11, 2003
Format: Paperback Verified Purchase
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.
Read more ›
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
19 of 20 people found the following review helpful By Y. Keselman on April 6, 2003
Format: Paperback
The book is a valuable resource for experienced programmers who are trying to write large, complex, real-life concurrent Java programs. The book discusses in depth many concurrency-specific issues you can run into, especially with Java. It gives tons of useful advice (in rather abstract form), both in text and in code (see the book's website for more complete examples). The book is full of useful frameworks and patterns.
However, it make take you a while to understand most of them. The author is fairly careless about the reader, and lets the reader do all the work. To understand one paragraph you may have to browse through 10 other pages, because that parargraph would reference them directly or indirectly. For example, to understand what is meant by "volatile" or "ThreadLocal", it helps to read several pages that precede these terms (and in other instances, you'd have to read several pages that follow). In other words, the book is not easily digestible, and many sections have to be chewed and re-chewed. The best way to approach the book would be to read it in "circles/spirals" and "in no particular order".
On the whole, the knowledge and understanding you get out of the book is worth the effort, but, I wish the author showed a bit more understanding for the reader. With a bit more work, the book could have been not only informative but also readable. For now, its readability is on par with a dictionary.
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
21 of 23 people found the following review helpful By A Customer on June 26, 2000
Format: Paperback
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.
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again

Most Recent Customer Reviews

Search

What Other Items Do Customers Buy After Viewing This Item?