Concurrent Programming in Java(TM): Design Principles and Pattern (2nd Edition)

Concurrent Programming in Java(TM): Design Principles and Pattern (2nd Edition)

$44.99 $38.24

  • Release Date: 05 November, 1999
  • Used Price: $26.49
  • Availability: Usually ships within 24 hours
  • Third Party Used Price: $36.38

Author: Doug Lea

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).

Similar Products

Effective Java Programming Language Guide

From $28.79:

Effective Java Programming Language Guide

Java Thread Programming

From $24.49:

Java Thread Programming

Taming Java Threads :

From $24.47:

Taming Java Threads :

Core J2EE Patterns: Best Practices and Design Strategies, Second Edition

From $34.99:

Core J2EE Patterns: Best Practices and Design Strategies, Second Edition

Java Performance Tuning (2nd Edition)

From $31.46:

Java Performance Tuning (2nd Edition)

Customer Rating: 4 of 5 (42 total reviews)

  • 5 starsA 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.

  • 5 starsFuture of concurrent programming in Java?

    Doug Lea's util.concurrent library, or something very similar is currently under evaluation for inclusion in JSDK 1.5. Java synchronization primitives as it stands are still too low level for many applications. Developing multi-threaded applications is difficult - even deceptively simple constructs like read-write locks (concurrent reads, exclusive writes) are notoriously difficult to get exactly right. This book assumes some familiarity with the basic Java synchronization primitives since it doesn't dwell much on explaining them. It isn't a reference manual on the util.concurrent library either. What this book does quite successfully, is bridge academic theory and practical programming to help the patient reader develop a real understanding of concurrent programming. Most programming books focus on the "what" or "how-to" aspects - this tackles the "why". A useful book considering there are currently very few design patterns, and refactoring strategies available to resolve concurrent programming problems.

  • 5 starsExcellent, Deep & Clear

    Doug Lea does an excellent work.
    On the one hand, he does much more than cover the API. He teaches you to *think* & understand multithreades. Example: he doesn't just state the java API won't let you modify a datastructure while iterating on it. He goes further to explain *how* java prevents this, and then details several methods to work around it. This particular example has greatly helped me with a project I'm on.
    On the other hand, I found the explanations clear and easy to follow. Great book...