- Paperback: 352 pages
- Publisher: Addison Wesley (Nov 1996)
- Language English
- ISBN-10: 0201695812
- ISBN-13: 978-0201695816
- Product Dimensions: 23.1 x 18.8 x 1.8 cm
- Average Customer Review: 3.9 out of 5 stars See all reviews (19 customer reviews)
- Amazon Bestsellers Rank: 434,323 in Books (See Top 100 in Books)
- See Complete Table of Contents
| ||||||||||||||||||
Did you know you can trade in your old books for an Amazon.co.uk Gift Card to spend on the things you want? Plus, get an extra £5 Gift Certificate when you trade in books worth £10 or more before June 30, 2012. Visit the Books Trade-In Store for more details. |
|
There is a newer edition of this item:
|
Product details |
More About the Author
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.
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)
|
Sell a Digital Version of This Book in the Kindle Store
If you are a publisher or author and hold the digital rights to a book, you can sell a digital version of it in our Kindle Store.
Learn more
What Other Items Do Customers Buy After Viewing This Item?
Customer Reviews
Most Helpful Customer Reviews
13 of 13 people found the following review helpful
Format: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.
10 of 10 people found the following review helpful
Format:Paperback
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...
4 of 4 people found the following review helpful
Format:Paperback
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.
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.
Would you like to see more reviews about this item?
Were these reviews helpful?
Let us know
Most Recent Customer Reviews
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
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
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
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
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
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
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
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
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
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
Listmania!
|
|
Look for similar items by category
- Books > Computing & Internet > Computer Science > Architecture & Microprocessors > Microprocessors > Parallel Processing & Computing
- Books > Computing & Internet > Programming > Languages & Tools
- Books > Computing & Internet > Programming > Languages > Java
- Books > Computing & Internet > Programming > Software Design, Testing & Engineering > Design Patterns
Look for similar items by subject
Feedback
- Would you like to update product info or give feedback on images?
- I am the Author, and I want to comment on my book.
- I am the Publisher, and I want to comment on this book.
