woodys-uk
Price: �26.56
In stock

Add to Cart

15 used & new from �0.85

See All Buying Options

Have one to sell? Sell yours here

Concurrent Programming in Java: Design Principles and Patterns

See larger image

Share your own customer images

Publisher: learn how customers can search inside this book.

Concurrent Programming in Java: Design Principles and Patterns (Paperback)

by Doug Lea (Author)

3.9 out of 5 stars See all reviews (19 customer reviews)

Available from these sellers.

5 new from �14.99 10 used from �0.85

Other Editions:	RRP:	Our Price:	Other Offers:
Paperback (2)	�40.99	�20.99	23 used & new from �20.00

12 Days of Christmas Sale in Books
Get up to 65% off some of our top titles. Shop now

› See more product promotions

Special Offers and Product Promotions

Illuminate your book with the innovative Philips LED reading light--exclusive to Amazon.co.uk. Shop now.

Customers Who Bought This Item Also Bought

Java Concurrency in Practice

by Brian Goetz

4.9 out of 5 stars (7) �16.46

Effective Java: Second Edition

by Joshua Bloch

4.8 out of 5 stars (8) �17.99

Refactoring: Improving the Design of Existing Code (Object Technology Series)

by Martin Fowler

4.3 out of 5 stars (20) �22.76

Java Puzzlers: Traps, Pitfalls, and Corner Cases

by Joshua Bloch

4.7 out of 5 stars (3) �14.49

Design patterns : elements of reusable object-oriented software

by Erich Gamma

4.6 out of 5 stars (38) �25.16

› Explore similar items

Product details

Paperback: 339 pages
Publisher: Addison Wesley (Nov 1996)
Language English
ISBN-10: 0201695812
ISBN-13: 978-0201695816
Product Dimensions: 24.1 x 19.7 x 1.9 cm

Average Customer Review: 3.9 out of 5 stars See all reviews (19 customer reviews)

Amazon.co.uk Sales Rank: 881,508 in Books (See Bestsellers in Books)
Popular in this category:
#76 in Books > Computing & Internet > Computer Science > Software Design, Testing & Engineering > Design Patterns

Would you like to update product info or give feedback on images?

See Complete Table of Contents

Product Description

Amazon.co.uk Review

Concurrent Programming in Java, second 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, the author also covers Java threads themselves (including priorities, scheduling and the like).

Next, 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 author presents dozens of techniques for letting threads work together safely. For the working Java programmer, coverage of patterns that have been implemented in downloadable java.concurrency package will be the most immediately useful. (Within this nearly encyclopaedic survey, short code snippets are used for every pattern and concept.) Though theoretically written 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, Amazon.com

Topics covered: Threads and concurrency in Java, design considerations: safety, liveness and performance, Before/After Patterns, layering, adapters, immutability and synchronisation, 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). --This text refers to an alternate Paperback edition.

Product Description

This text treats Java as a software engineering language rather than a means of developing simple applets. It aims to enable programmers to find out more about how to use concurrency in the design of classes, applets and applications to create multi-threaded applications. Features of the book include integrated surveys and tutorials on concurrency and Java programming constructs, and reusable components and micro-architectures solving common software construction problems.

See all Product Description

Suggested Tags from Similar Products

(What's this?)

Be the first one to add a relevant tag (keyword that's strongly related to this product)

java concurrency

java

programming

parallelism

parallel

concurrent

What Do Customers Ultimately Buy After Viewing This Item?

	40% buy Java Concurrency in Practice 4.9 out of 5 stars (7) �16.46
	40% buy the item featured on this page: Concurrent Programming in Java: Design Principles and Patterns 3.9 out of 5 stars (19)
	13% buy Effective Java: Second Edition 4.8 out of 5 stars (8) �17.99
	4% buy Java Threads 4.4 out of 5 stars (7) �16.99

Explore similar items

Customer Reviews

19 Reviews

5 star:		(10)
4 star:		(4)
3 star:		(1)
2 star:		(1)
1 star:		(3)

Average Customer Review

3.9 out of 5 stars (19 customer reviews)

Share your thoughts with other customers:

Create your own review

Most Helpful Customer Reviews

13 of 13 people found the following review helpful:

5.0 out of 5 stars Excellent, 22 Feb 2000

By A Customer

This review is from: Concurrent Programming in Java: Design Principles and Patterns (Paperback)

This book stresses design principles over API teaching - most if it is dedicated to illustrating the issues that arise in multi-threaded systems, and then to presenting design patterns that over come these difficulties.

It is well written, and the issues raised are illustrated with code snippets (as opposed to complete programs) in Java - no type-and-run listings in this book.

The emphasis of design over implementation makes it best suited to those who already have a good knowledge of Java and OO design ideas. The threading API is covered very well, but I'd look elsewhere if you are looking for an introduction to it.

Comment Comment | Permalink | Was this review helpful to you? Yes No (Report this)

10 of 10 people found the following review helpful:

4.0 out of 5 stars Good Solid Information, 20 May 1999

By A Customer

This is a good, solid book. I don't understand some of the comments here - although not aimed at people with little programming experience, it is not impenetrable or badly written. It is not an academic textbook, but neither is it an inspirational classic. It's simply a good explanation of many of the issues involved in concurrent programming - the best I have read.

An experienced Java programmer who has already used and worried about threads could read this in a couple of days and learn a great deal - at least, I certainly did. The emphasis on patterns really helps - this is the first book I have seen that uses patterns as a tool and succeeds. They clarify the argument and let the reader decide whether they want to continue with a particular section or skip over to something more interesting.

Some of thread programming is difficult and, at least at the moment, there is no way to avoid thinking about the problem - but even in the detailed discussions of the final chapter, concentrating on particular examples, there were useful general comments.

My only criticisms are: (1) The organisation of the book wasn't as clear as it could be - it wasn't until I had read it from cover to cover that I felt I could find particular items of information. (2) There was little mention of Hoare's CSP/occam and the related Java work done at the University of Kent (I'm not an expert on this, but I found that work very useful and wished it had been discussed here). Amazon doesn't seem to like links from its pages, but I am not connected with these people and think readers here would be interested in this, so please - leave in this pointer: http://www.cs.ukc.ac.uk/projects/ofa/jcsp/ Thanks!

Incidentally, if you are hoping this is a manual for Doug Lea's respected concurrency package - it isn't. I read the book hoping it would be, but I wasn't disappointed because, once I had finished the book, I found the package (with the online docs) easy to understand. So the book complements (and funds!) the package, but isn't a manual - it's much more useful than that...

Comment Comment | Permalink | Was this review helpful to you? Yes No (Report this)

4 of 4 people found the following review helpful:

4.0 out of 5 stars Not light bedtime reading, 10 Oct 1997

By A Customer

I have both Doug Lea's "Concurrent Programming in Java" and Oaks and Wong's "Java Threads". Doug Lea's book is by far the most comprehensive. The book focuses strongly on applied uses of locking mechanisms and covers a great deal of the theoretical basis of monitor-based locking schemes. The book is not easy reading though -- it is extremely dense. It has applicability outside of the Java programming environment and I recommend it to you if you are interested in the theoretical side of concurrent programming. Oaks and Wong's book is far less academic. It is an extremely easy read. Notwithstanding the fact that it is 250 pages, it can easily be read (and understood) in an afternoon. Their approach is much more practical and focuses on Java's support for concurrent programming. If you need to dive into multi-thread programming in Java then I heartily recommend this book to you as it will get you started quicker than Doug Lea's book. If your interest is in concurrent programming in general or if you are using a different language, then Doug Lea's is probably the more suitable.

Comment Comment | Permalink | Was this review helpful to you? Yes No (Report this)

Share your thoughts with other customers: Create your own review

› See all 19 customer reviews...

Most Recent Customer Reviews

1.0 out of 5 stars Does more to obfuscate the topic than explain it
I bought this book on the strength of several Amazon reviews, which praised it highly. However, it is easily the worst computer textbook I have ever owned. Read more

Published on 15 Jun 2004 by C. Wareham

1.0 out of 5 stars Waste of time and money
I purchased this book as a recommended course text. So far course texts have been readable and good quality however this book is a different matter. Read more

Published on 2 Mar 2001

5.0 out of 5 stars Excellent overview of all multi-tasking flavours
This book is a must-have for those who need an in-depth introduction to multi-tasking in Java. It explains all standard concepts (thread-safety, lifeness, semaphores, etc . . . Read more

Published on 4 Jun 2000

5.0 out of 5 stars Well worth the effort it demands.
Although this is definitely the most difficult programming book I've ever read, it has also been the most valuable. Read more

Published on 18 Mar 1999

2.0 out of 5 stars It's a good book, but it may not be worth the effort
The other reviewers weren't kidding about this book being dense and difficult to read. The problem I have with it is not its difficulty but because most of it is cause by poor... Read more

Published on 26 Feb 1999

5.0 out of 5 stars heady stuff
Beginners don't bother. But for real programmers, this is a great book, albeit not a particularly easy one.

Published on 23 Feb 1999

3.0 out of 5 stars Extremely Theoritical
This book mainly goes over the theory of Java Threads and works more as a guide to thread programming than a how-to book. Read more

Published on 22 Feb 1999

1.0 out of 5 stars Way over my head!
I tried hard to understand the content of this book however,it made litte or no sense to me. I am a novice Java programmer but have several years of experience in other... Read more

Published on 11 Dec 1998

4.0 out of 5 stars Excellent for the experienced
I found the book to be excellent because I need a book that would allow me to map my knowledge of concurrency from other languages to Java. Read more

Published on 9 Oct 1998

5.0 out of 5 stars No pain no gain - and the gain is substantial
Doug covers some complex concepts in multithreading that go beyond merely describing how to multithread Java applications. Read more

Published on 10 Jun 1998

› See all 19 customer reviews...

.jsOffDisplayBlock { display: block; } .jsOffDisplayInline { display: inline; } .jsOffVisibility { visibility: visible; } .jsOnDisplayBlock { display: none; } .jsOnDisplayNoneBlock { display: block; } .jsOnDisplayNoneInline { display: inline; } .jsOnDisplayInline { display: none; } .jsOnVisibility { visibility: hidden; } .jqOnDisplayBlock { display: none; } .jqOnDisplayInline { display: none; } .jqOnVisibility { visibility: hidden; } .jqOnDisplayNoneBlock { display: block; } .jqOnDisplayNoneInline { display: inline; }