Java Threads | 
 enlarge | Authors: Scott Oaks, Henry Wong
Publisher: O'Reilly Media, Inc.
Category: Book
List Price: $39.95
Buy New: $22.33
You Save: $17.62 (44%)
New (32) Used (14) from $10.62
Avg. Customer Rating:  40 reviews
Sales Rank: 152692
Format: Illustrated
Media: Paperback
Edition: 3
Number Of Items: 1
Pages: 358
Shipping Weight (lbs): 1.3
Dimensions (in): 9.3 x 6.9 x 0.9
ISBN: 0596007825
Dewey Decimal Number: 005.133
EAN: 9780596007829
ASIN: 0596007825
Publication Date: September 10, 2004
Availability: Usually ships in 1-2 business days
Condition: All orders ship same business day via standard shipping (USPS Media Mail) if received by 1 PM CST.
|
| Also Available In:
|
| Similar Items:
|
| Editorial Reviews:
Amazon.com Review
Building sophisticated Java applets means learning about threading--if you need to read data from a network, for example, you can't afford to let a delay in its delivery lock up your entire applet. Java Threads introduces the Java threading API and uses non-computing analogies--such as scenarios involving bank tellers--to explain the need for synchronization and the dangers of deadlock. Scott Oaks and Henry Wong follow up their high-level examples with more detailed discussions on building a thread scheduler in Java, dealing with advanced synchronization issues, and handling exceptions.
Product Description
Threads are essential to Java programming, but learning to use them effectively is a nontrivial task. This new edition of the classic Java Threads shows you how to take full advantage of Java's threading facilities and brings you up-to-date with the watershed changes in Java 2 Standard Edition version 5.0 (J2SE 5.0). It provides a thorough, step-by-step approach to threads programming. Java's threading system is simple relative to other threading systems. In earlier versions of Java, this simplicity came with tradeoffs: some of the advanced features in other threading systems were not available in Java. J2SE 5.0 changes all that: it provides a large number of new thread-related classes that make the task of writing multithreaded programs that much easier. You'll learn where to use threads to increase efficiency, how to use them effectively, and how to avoid common mistakes. This book discusses problems like deadlock, race conditions, and starvation in detail, helping you to write code without hidden bugs. Java Threads, Third Edition, has been thoroughly expanded and revised. It incorporates the concurrency utilities from java.util.concurrent throughout. New chapters cover thread performance, using threads with Swing, threads and Collection classes, thread pools, and threads and I/O (traditional, new, and interrupted). Developers who cannot yet deploy J2SE 5.0 can use thread utilities provided in the Appendix to achieve similar functionality with earlier versions of Java. Topics include: - Lock starvation and deadlock detection
- Atomic classes and minimal synchronization (J2SE 5.0)
- Interaction of Java threads with Swing, I/O, and Collection classes
- Programmatically controlled locks and condition variables (J2SE 5.0)
- Thread performance and security
- Thread pools (J2SE 5.0)
- Thread groups
- Platform-specific thread scheduling
- Task schedulers (J2SE 5.0)
- Parallelizing loops for multiprocessor machines
In short, this new edition of Java Threads covers everything you need to know about threads, from the simplest animation program to the most complex applications. If you plan to do any serious work in Java, you will find this book invaluable. Scott Oaks is a senior software engineer for the Java Performance Engineering group at Sun Microsystems and the author of four books in the O'Reilly Java series. Formerly a senior systems engineer at Sun Microsystems, Henry Wong is an independent consultant working on various Java related projects.
|
| Customer Reviews: Read 35 more reviews...
 Alright one could say August 13, 2008
Not the best for learning about Java Threads, but you can use it as a reference when you have a different better book to understand all of the technical jargon...
 Lots of experimental data, clear answers April 2, 2007
1 out of 2 found this review helpful
This book provides answers to questions on threading that have confused me for a long time:
1. Why use a thread pool and why not?
2. How expensive are synchronization, thread creation and concurrent collections?
It clears up a lot of myths and rumors I have heard.
review of first edition June 1, 2006
3 out of 3 found this review helpful
Before I bought this book, I had to prototype threading examples in my own workspace, setting up race conditions and such, but it was a lot of work and left a lot unexplained.
Scott Oaks, the author, did a good job of describing the synchronization process and the various Object methods relating to threading protocol. There were plenty of good examples, and clarification on several minor technical points including: how the wait/notify methods release monitors, the determinability of prioritization, and the practical uses of threadgroups. If you have nagging questions, you may find them answered here.
O'Reilly books are small-sized, which makes for easy carrying and storage. Little if any of their content is redundant or inaccurate. Given how dry the material is, O'Reilly astounds me by consistently finding authors who can write well, have something to say, and whose works can be read in a sitting.
Of course, it's important to mention that some things have changed since the first edition of this book. Methods like resume(), suspend(), and stop() have been deprecated due to their unpredictablity; the JVM will now enable programmers to address multiple processes; and there are a variety of classes which facilitate thread administration. A newer edition will bring you up to speed on those details, but this first edition is still a valid reference in all other respects.
Comprehensive coverage of multithreading and Java 5 inclusions. May 8, 2006
6 out of 6 found this review helpful
<< Review of the 3rd Edition >>
This book is written for developers who are targeting the second wave of java programs - Intermediate to advanced level programmers will be able to get best value out of this book. Developers who are already familiar with the basics of java may also be able to get some value, but if you are completely new to java, please look elsewhere.
Without any futher ado, i will dive right into the deep end of the pool. This book is partitioned into 4 logical sections, though it is not explicit in the TOC.
1. Important Threading Concepts:
In this section, the author prepares us with the fundamentals of creating and managing a thread, basic synchronization concepts, synchronized keyword, lock mechanism, thread communication using wait-notify and condition-variables, minimal synchronization using volatile keyword and atomic variables, advanced synchronization classes like Barrier, Semaphore, CountdownLatch, etc. Chapters 1 through 6 underwrite this section and this is by-far the best part of the book.
2. Thread Pools/Schedulers:
This section first lectures around how thread scheduling materializes in java and how it is related to the underlying Operating System. Next, you are guided through a tour of Thread Pools and Task Schedulers that will enlighten us with quite a few new classes in java 5. Chapters 9 through 11 cover this section.
3. Threading and other Java APIs:
This section details how the threading API plays with other inbuilt java APIs like Collections, IO and Swing. Chapters 7,8 and 12 cover this section.
4. Misc topics:
Some miscellaneous thread topics like ThreadGroup, Security, Class Loading, Exception Handling and Performance are addressed in this section. Chapters 13, 14, and 15 cover this section.
Though this book wasn't an easy read, i found it extremely encouraging to have ONE comprehensive manual to understand both the threading concepts and the new java 5 inclusions. I recommend this book to anyone who is in the middle of a complex multi-threaded system or wishes to create one.
Possible second read on Java Threads. March 7, 2005
4 out of 11 found this review helpful
Obviously your first read on Java should be "Concurrent Programming in Java(TM): Design Principles and Pattern" by Doug Lea. If this does not completely satisfy you this might be a possible second read on the subject. This book has a somewhat different perspective that it is closer to the classes and more distant to the principles. Here it delivers a good groundwork.
|
|
|
News 
