Customer Reviews:
Good Text, Lack of Details on Concurrent Package is a turn off.......2007-09-14
Simply put this book can be viewed from a love it or hate it perspective, but personally when i bought Java Generics and Collections ( O Reilly ) i was impressed by the depth of their coverage, it gave me that inside edge and the internal knowledge of generics and collections ( how they work etc. ) This Book works well in giving what to do, what could have been done better and some portions on Concurrent package, but simply put I AM NOT SATISFIED WITH ITS COVERAGE ON CONCURRENT PACKAGE!. if you stack up generics against this one, i'd say generics is 200% better than this one.
So yea i was a bit disappointed with the book. But hey, nothing works better than the Java Language Spec Third edition =). ( at least it gives you everything exhaustively ).
Regards
Vyas, Anirudh
Avoid those unrepeatable bugs!.......2007-08-22
Java Concurrency in Practice gives very complete coverage on the language's concurrency classes introduced in Java 5 & 6. It shows you the shortcomings of previous attempts at concurrency in earlier versions of the JDK, with great code samples.
This book is pretty comprehensive and goes through the thinking/theory of why things are written the way they are, it is not just a paper version of the JavaDoc reference.
It is also very, very readable. I am by no means experienced in concurrency problems, but it was very easy to follow through the reasoning and examples. (my background is a CS degree and 1.5 years in the industry)
This book is a must read, especially for Java devs. Even if you are not a Java programmer, it could still be an enlightening read because it tells you how to structure your programs to deal with concurrency and how to deal with concurrent stateful apps, which unless you are using Erlang, is something you have to deal with.
beginner-oriented.......2007-07-25
Good book, yet IMO it's too "for beginners". Authors seem to explain things very slowly, perhaps it's great for people with little programming experience, but I found the tempo a bit slow.
I think that Concurrent Programming in Java by Doug Lea is more appealing to experienced developer, unfortunately I don't think there is a new edition out that covers Java 5. When/if new edition comes out, I'll switch, but for now I'd stick with Java Concurrency in Practice.
Teaches clear thinking in thread programming.......2007-06-22
Perfectly lucid style combined with a number of architectural patterns makes this book a treasure. Totally love it.
Very useful book on an increasingly important topic.......2007-06-05
I have been programming in Java for years, and yet I've generally ignored or otherwise avoided dealing with concurrency and synchronization at every opportunity because I found it so daunting. This book broke down that barrier for me and helped me to understand what I needed to do to write correct concurrent programs. In particular, the book provides concrete instructions that I was able to apply to projects that I am working on right now.
I would highly recommend this book to any Java programmer, as you are probably missing out on part of the capabilities of your language (and/or writing incorrect programs!) until you read this. It's probably not a bad lesson for developers of concurrent software in any language, but the concrete instructions regarding Java were really the most valuable part of the book to me.
Amazon.com
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.
Book 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:
Lots of experimental data, clear answers.......2007-04-02
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.......2006-06-01
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........2006-05-08
<
< 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........2005-03-07
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.
A good reference book on Java Threads........2004-12-22
Review Date: Dec 2004.
Please Rate the overall value of the book from 1-5 where
5=Well done! This book will be a valuable teaching and reference tool.
Please rate the instructional value of the book from 1-5 where
5=Excellent! An essential book on this topic.
Please rate the reference value of this book from 1-5 where
4=This book has earned a valued place on my reference shelf.
This is a book for Java programmers of all proficiency levels; the book also provides information for
advanced users of Java. the book uses J2se 5.0 version of the compiler - and explains the
improvements in the threads implementation in this version of java.
the book is a well written book with a gradual introduction to the various aspects of thread
implementation and a detail study of the subject. the authors delves into various of aspects of
thread implementation such as creation, management, data synchronization, notification, scheduling,
pooling, performance, parallelizing loops, and other IO functions.
there are sample codes through out the book and the codes make no assumption about the skill level of
the reader. this is a good thing. there are enough diagrams to explain the threading concepts.
overall, this is an excellent book for readers interested in concurrent programming. i will use it as
a reference when i need and i have no hesistation in recommending this book to other java programmers.
Average customer rating:
- Deals with the subject!!!
- Clear and Concise! Excellent book for beginners in Java.
- Excellent Book for learning Threads in JAVA
- Very clean intro but a bit dated
- A particularly easy to understand book
|
Java Thread Programming
Paul Hyde
Manufacturer: Sams
ProductGroup: Book
Binding: Paperback
 General
| Java
| Programming
| Computers & Internet
| Subjects
| Books
General
| Languages & Tools
| Programming
| Computers & Internet
| Subjects
| Books
Parallel Processing Computers
| Hardware
| Computers & Internet
| Subjects
| Books
General
| Software
| Computers & Internet
| Subjects
| Books
Mathematics
| Professional Science
| Professional & Technical
| Subjects
| Books
| Applied
| Chaos & Systems
| Geometry & Topology
| Mathematical Analysis
| Mathematical Physics
| Number Systems
| Pure Mathematics
| Transformations
| Trigonometry
Look Inside Computer Books
| Trip
| Specialty Stores
| Books
All Titles
| Qualifying Textbooks - Fall 2007
| Stores
| Books
Computers & Internet
| Qualifying Textbooks - Fall 2007
| Stores
| Books
Professional
| Qualifying Textbooks - Fall 2007
| Stores
| Books
Similar Items:
-
Java Concurrency in Practice
-
Concurrent Programming in Java(TM): Design Principles and Pattern (2nd Edition)
-
Java Threads (Java Series (O'Reilly & Associates))
-
Concurrent and Real-Time Programming in Java
-
Taming Java Threads
ASIN: 0672315858 |
Book Description
Java Thread Programming shows you how to take full advantage of Java's thread facilities: when to use threads to increase your program's efficiency, how to use them effectively, and how to avoid common mistakes. There is thorough coverage of the Thread API, ThreadGroup classes, the Runnable interface, and the synchronized operator. Extensive, complete, code examples show programmers the details of creating and managing threads in real-world applications.
Download Description
Comprehensive and professional approach to multi-threaded Java programming and development with the Java Thread APIs extremely practical, hands-on book that contains concise descriptions of the theory, complete applications, and thousands of lines of proven, real world Java code Paul Hyde is a professional Java developer and a Sun Certified Java Programmer who has worked for Lucent Technologies, Sybase, and now is President of Programix, Inc., a company that specializes in Java development
Customer Reviews:
Deals with the subject!!!.......2007-01-09
It's amazing how much is assumed in most after-market Java books! I can't estimate how often I've seen, "It is assumed you know about Threaded Programming, and therefore it is not covered here." Well, good news, It IS covered here. And is is covered well.
As a professional programmer for 20 years, I can attest to the fact that Thread programming is the most schizophrenic of disciplines. In addition, since most legacy thread concepts come from 'procedural' languages, the Java implementation tends to be hard to hold on to.
I found this book to be a wonderful 'primer' into Java's Thread capabilities. It doesn't attempt to relate to older languages. It starts from the begining, and presents its subject clearly. It's a good learning tool, and is organized well enough to be a reliable refference.
Even if you have experience with threading, this is worth it to orient your head to Java Threading.
Clear and Concise! Excellent book for beginners in Java........2006-12-09
If you find Doug Lea's "Concurrent Programming in Java" too daunting, this is the book you should have read first. The examples were easy to follow, and were to the point -that is, you will only learn how to work with the Thread API, and there is not much talk about design patterns. The diagrams in the book were very handy to follow Hyde's explanation. I enjoyed reading this book.. I recommend this book for every beginner in java programming.
Excellent Book for learning Threads in JAVA.......2006-11-03
This is a good book to learn Thread fundamentals and how to use thread in Real Life. The code examples uses a lot of AWT thats why the 4 stars I would have been a little bit happier if it used something else.
Any way a good purchase for learning Thread I brushed up my knowledge on Thread before sitting for the SCJP
Very clean intro but a bit dated.......2005-02-15
Very straightforward and gentle introduction to the Java threading mechanics.It features basic theory and examples for about 3/4 of the book with the rest of the pages dedicated to a few useful techniques to ease and streamline threads programming, which you can use in you applications or as inspiration and examples for your own devices. My only complaint is the presentation method: a bunch of code followed by a bunch of explanations. I think presenting the more relevant lines of code interleaved with explanations and then the whole example program would make learning much more effective and easy. This book is also starting to show its age, so until a second edition comes out I would recommend the O'Reilly book over this one, unless you can get it real cheap.
A particularly easy to understand book.......2004-11-30
This is a particularly easy to understand book on Java threads. If you are new to Java or to threading then don't hesitate to buy this book. The topics are clearly explained and in a logical order. The examples are small enough that they are easy to understand, but big enough to get the point across. And they work! Mr. Hyde has clearly gone to a great amount of trouble to make his presentation clear and simple to digest. As examples the diagrams he presents for explaining a deadlock and the timing of events in a wait/notify sequence make what is going on very clear.
If you are an experienced thread programmer looking for the finer points of threading, this book might not be the best. It does not go into the level of detail that some other books do, for example Holub's book "Taming Java Threads". On the other hand, these books are not the best for beginners.
Book Description
Master the essentials of concurrent programming,including testing and debugging
This textbook examines languages and libraries for multithreaded programming. Readers learn how to create threads in Java and C++, and develop essential concurrent programming and problem-solving skills. Moreover, the textbook sets itself apart from other comparable works by helping readers to become proficient in key testing and debugging techniques. Among the topics covered, readers are introduced to the relevant aspects of Java, the POSIX Pthreads library, and the Windows Win32 Applications Programming Interface.
The authors have developed and fine-tuned this book through the concurrent programming courses they have taught for the past twenty years. The material, which emphasizes practical tools and techniques to solve concurrent programming problems, includes original results from the authors' research. Chapters include:
* Introduction to concurrent programming
* The critical section problem
* Semaphores and locks
* Monitors
* Message-passing
* Message-passing in distributed programs
* Testing and debugging concurrent programs
As an aid to both students and instructors, class libraries have been implemented to provide working examples of all the material that is covered. These libraries and the testing techniques they support can be used to assess student-written programs.
Each chapter includes exercises that build skills in program writing and help ensure that readers have mastered the chapter's key concepts. The source code for all the listings in the text and for the synchronization libraries is also provided, as well as startup files and test cases for the exercises.
This textbook is designed for upper-level undergraduates and graduate students in computer science. With its abundance of practical material and inclusion of working code, coupled with an emphasis on testing and debugging, it is also a highly useful reference for practicing programmers.
Download Description
Master the essentials of concurrent programming,including testing and debugging This textbook examines languages and libraries for multithreaded programming. Readers learn how to create threads in Java and C++, and develop essential concurrent programming and problem-solving skills. Moreover, the textbook sets itself apart from other comparable works by helping readers to become proficient in key testing and debugging techniques. Among the topics covered, readers are introduced to the relevant aspects of Java, the POSIX Pthreads library, and the Windows Win32 Applications Programming Interface. The authors have developed and fine-tuned this book through the concurrent programming courses they have taught for the past twenty years. The material, which emphasizes practical tools and techniques to solve concurrent programming problems, includes original results from the authors' research. Chapters include: * Introduction to concurrent programming * The critical section problem * Semaphores and locks * Monitors * Message-passing * Message-passing in distributed programs * Testing and debugging concurrent programs As an aid to both students and instructors, class libraries have been implemented to provide working examples of all the material that is covered. These libraries and the testing techniques they support can be used to assess student-written programs. Each chapter includes exercises that build skills in program writing and help ensure that readers have mastered the chapter's key concepts. The source code for all the listings in the text and for the synchronization libraries is also provided, as well as startup files and test cases for the exercises. This textbook is designed for upper-level undergraduates and graduate students in computer science. With its abundance of practical material and inclusion of working code, coupled with an emphasis on testing and debugging, it is also a highly useful reference for practicing programmers.
Customer Reviews:
Concepts are nice but reading it is terse.......2007-08-14
I think it was a pretty decent writing but certain parts can be hard to follow and i thought a combination of code + graphics would make it an even better read
Good ideas but badly presented.......2007-08-10
Some background first as it is relevant to the review - I have over 20 years software development experience, including extensive multi-threading (on Windows, UNIX and other operating systems) developing high-performance data feed handlers etc. I've read many books that are either about multi-threading or touch on multi-threading, but bought this one because of the "Testing and Debugging" in the sub-title as this is an area the others tend to skip.
Now about the book - four negatives first, but do read the positives afterwards as well as they are big positives...
The first thing that hit me when reading this book was how old-fashioned it looks. For a book called "Modern Multithreading" you would think that Wiley (the publishers) would have presented the book better. The drab brown cover doesn't really matter, but the formatting of the text inside does. Source listings are shown in the same typeface as surrounding text, with no border etc to differentiate them. Worse is that if the text refers to a listing, the listing is likely to be on the next page wrapped in text about something else. The whole presentation is really poor.
The second thing that hit me, which is more significant, is that the authors simply do not write well. There can be no doubt that the authors are academics and that this book is a text book - it is not an easy read and comes across as being a bound version of all of the photocopied hand-outs that you can imagine being given out at lectures during a computer science degree course. If you think of hand-outs as being notes that are typed up to support what was said during the lectures then you can imagine how they read. Put over 400 pages of them together and you get a feel for this book. Difficult (but worth persevering).
The third negative, is that the code samples are described as a library, but they are not seriously useable as such. Maybe we've been spoilt by some of the excellent C++ and Java books that have been produced over recent years, but it has become common to be able to lift useful bits of code from books and reuse them without change. The code in this book is not like that. Good for research but not for serious use without being reworked. I have downloaded the full source code from the author's web-site (it doesn't all appear in the book) and found that for serious use it (a) needs some bugs fixed, (b) needs better error handling, (c) need optimising, (d) needs general reworking (it wouldn't pass code review the way it stands).
Fourthly, the index is incomplete and there is not a glossary. Why is this a problem? Well, given how difficult a read this is you can imagine how easy it is to glaze over. I clearly did that somewhere as I missed the meaning of an abbreviation that was then used repeatedly later on. I must had seen that same abbreviation used half a dozen times before thinking that I really should find out what it means as it seemed to be getting increasingly significant. I looked for a glossary but there isn't one included. I looked in the index to find the first page the abbreviation was used. Unfortunately the index didn't list the first page it was used, so I ended up scanning all the way from the start of the book to find the meaning. I'm very glad to have found it, because the moment I did the whole intention of the book started falling into place (although that wasn't confirmed until more than 140 pages in - see below).
Now for the plus points - well, one anyway...
This book covers something I have never seen any other book attempt to do. Most books say something along the lines of "multi-threading is hard, testing and debugging multi-threaded programs is really difficult and we're not going to give you any advice about how to do it". Well not this book. You may need to get more than 140 pages into the book before it reaches the really interesting ideas, but this book attempts to explain how to trace the interactions between different threads and to provide a way of replaying the same sequence in order to test/debug problems. As well as that it gives methods that will help to identify race conditions and deadlocks (where most books describe what they are and then go no further). Given that pre-emptive multi-threading gives you a system that is inherently non-deterministic, to attempt to provide repeatability by building a layer over the usual synchronisation mechanisms is a really interesting idea. It slows your code down so you don't want to put it into production code (another change required to the code), but during development it could be really handy. It doesn't give you a completely deterministic system, but helps to make the main interactions between threads more repeatable.
So to summarise - a couple of very interesting ideas that are incredibly badly presented, but given that I have never seen any other book try to describe the same material I'm afraid that there is no better book to recommend (please tell me if there is!). I've started using the ideas presented in this book in my own code, fixing/enhancing the code from the book in the process. Given that getting this code into a "professional" condition is a non-trivial task, that should give an idea of how useful I think the ideas are. Its taken a couple of weeks to integrate into my own threading library, but tracing, race condition detection and deadlock detection are working, though the deadlock detection mechanism is pretty primitive - I may do further work on that to make it more useful. Although I have coded the replay mechanism I haven't tested that yet - will update this review with the result when I have time to test it.
If you are new to multi-threading buy something easier to read as a tutorial, but if you already have good multi-threading experience and want to build your own framework combine the material from this book, with ideas from "Programming with Hyper-Threading Technology" and (for Windows) details from "Programming Applications in Microsoft Windows".
Like a grad. level paper: Helpful, if you can read it........2006-10-06
I got this book hoping for helpful ideas on how to debug multithreaded programs. This book has them, but the writing isn't that clear or readable. It reads like a grad. level paper more than a standard technical book that most of us are used to.
The book lightly covers standard multithreading concepts and objects, but you're better off learning those someplace else because I'm sure it's explained in more "laymen" terms elsewhere. The one thing this book does do well is offer a way for you to write mutexes, semaphores, monitors, etc. in a way that would allow you to replay a given run of a multithreaded program (assuming you also can reproduce the input to said program somehow). If you know how to debug a single threaded application, this ability makes it easier to debug a multithreaded program. (As things become determisitic.)
However, if you already have a program that you're trying to debug, you end up out of luck, unless you want to port your program to use these new libraries.
Also note that all the examples in this book are for C++ or Java. C doesn't have the object-oriented abilities that would be needed to easily use the examples.
Customer Reviews:
Fascinating, flawed but essential.......2005-01-25
This is the only book I have seen that thoroughly covers how threads are implemented in a modern OS and how this affects how code runs. It's certainly the most useful book on threading I have. It's a good book to buy after you've written some concurrent code and have some problems.
It's not a Java book - it's a platform focused
multithreading book. It could do with some restructuring to make it more accessible.
Great under-the-hood book for experienced developers.......2002-03-17
This was the first threading book I read--which turned out to be a huge mistake. The material is very dense and only a small part of it is Java. Most of the book deals with operating system threading concepts. There is a lot of space dedicated to contrasting MS vs. Unix threading models. Also, comparisons between Java and c threading.
If you are looking for a solid beginner book on Java threading (or threading in general), I highly recommend Concurrency: State Models & Java Programs. This is the second threading book I read and I highly recommend it if your goal is to _understand_ thread theory and problems. It approaches the subject in a very rigorous manner and models all concepts using finite state machines and then showing the Java source code.
If you are already comfortable with basic threading concepts and some systems programming then I would recommend the Multithreaded Programming with Java Technology.
I deducted a star because of a few annoying typos and for a few convoluted sections.
Little to do with Java besides the title.......2002-02-23
That this book was a member of the Sun Java series was the primary reason make me take a look at this book.
I have been highly disappointed. This body of work for this book is primarly a rushed port of the authors other title - named, funnily enough Multithreaded Programming with PThreads.
The Java topics seem to be bolted on as an after-thought - and makes the book read and present very badly. For example a good amount of examples are presented in C not Java, demonstrating POSIX threading!
The author is also in the bad habit of presenting material out-of-order, so that the reader has to wait sometimes 50 pages for clarification. This does not breed suspense, merely frustation at the disorder.
The low-level OS technical coverage is quite adequate - with a good explanation of LWP and POSIX threading (if only this is what I bought the book for!).
The author is clearly a C type who has come to Java and tries to basically recreate the semantics of C POSIX threading in Java... while at the same time constantly drifting back to a topic that he is clearly more comfortable with - PThreads.
This is hardly an embracing approach for a book with the word Java in the title - an obvious cash-in on the behalf of the publisher, Prentice Hall.
Do not buy this book.
it cover de ground mon, and a lot more too........2002-01-06
Any book on multithreading this well written and illustrated and going from test-and-set to volatile- well mon, you gots to
understand what you getting- the very best. Mucho kudos to the
writers and their collaborators- power players if there ever were power players. I give it a ten.
Disorganized Mess.......2001-07-20
I purchased this book hoping to develop a deeper understanding of multi-threading, the proverbial under-the-hood down and roll-your-sleeves-up nitty gritty. Frankly this book left me quite disappointed. It's poorly organized and poorly editted. While I am sure it has some valuable content, the low readability level and very poor organization (it really gives the impression that it was sort of patched together) prevented me from ever getting into it. In my humble opinion, the book
"Taming Java Threads" by Allen Holub is a fare better choice if you want to master Java threads.
Book Description
Understanding the main principles and algorithms underlying a modern operating system is essential in undergraduate computer science. The complexity of this subject, however, means that mastering it requires significant practical experience. This unique book accomplishes just that: it teaches introductory subjects in OS design and implementation through hands-on engagement with OSP 2, the next generation of the highly popular OSP courseware.
This book exposes students to many essential features of operating systems while at the same time isolating them from low-level, machine-dependent concerns. With its accompanying software, the book contains enough projects for up to three semesters. Even one semester's study, however, suffices to cover page-replacement strategies in virtual memory management, CPU scheduling strategies, disk seek-time optimization and other issues in operating system design.
Features include:
• Provides an opportunity to practice OS design and implementation skills in a realistic, flexible, and easy-to-use systems programming environment that promotes "active learning" and reinforces lecture material.
• OSP 2 is written in Java, so that students learn an object-oriented approach to OS design and implementation.
• Contains many pedagogical tools: chapter goals, internet support for students and instructors; OSP 2 courseware and an instructors' manual, which includes helpful tips for course instructors and sample assignments, is available at
www.springer.com/978-1-84628-842-5.
• Each chapter includes self-contained explanations of the OS concepts underlying the student project for that chapter.
Written for undergraduates in a first operating systems course, this text provides essential foundations through the user-friendly, highly flexible OSP 2 courseware environment.
Average customer rating:
- Stolen Obsolete Book
- 2 days not enough but a good book anyway
|
Mastering Java Threads Two-Day Course
Marc Adler , and
David Herst
Manufacturer: D D C Pub
ProductGroup: Book
Binding: Spiral-bound
General
| Java
| Programming
| Computers & Internet
| Subjects
| Books
General
| Programming
| Web Development
| Computers & Internet
| Subjects
| Books
ASIN: 1562438425 |
Book Description
Two-day course. Includes data disk.
Mastering Java Threads is an intermediate two-day Java course that covers, in detail, all of the thread facilities available in the Java JDK. This course also teaches many common thread patterns and strategies to avoid race conditions and deadlocks. Mastering Java Threads incorporates extensive code examples and hands-on exercises.
Mastering Java Threads incorporates extensive code examples and hands-on exercises. This is a programmer-centric course intended for anyone developing applications in Java. DDC's Mastering Java is the prerequisite to this course
Mastering Java Threads focuses on the following topics:
Single threaded vs multithreaded applications
Concurrent execution
Thread attributes
Run() method
The Thread Class in C
Runnable, Not Runnable, and Dead states
isAlive() method
Daemon threads
Priority values
The scheduler, time slicing, and starvation
ThreadGroups & ThreadGroup naming
Enumerating Threads wihtin a ThreadGroup
Limiting priorities
Java security and the checkAccess() method
Synchronization and monitors
The scope of a lock
Object and Class locks
Synchronized blocks vs. methods
Deadlock
Customer Reviews:
Stolen Obsolete Book.......2003-02-23
This book is course written and owned by SkillBuilders, Inc. Legal actions are pending, one publisher involved in the theft has already paid damages and we anticipate additional judgements/settlements against those who illegally use our copyrighted material.
Aside from that, the material in the book offered here was written in 1999 and earlier. Obviously there have been quite a few changes and updates since that time. Our active courses at SkillBuilders are all up to date. They would be a much better choice.
2 days not enough but a good book anyway.......2000-04-28
Although the book is very informative about threads, 2 days is not enough to understand all the concepts of multithreading. There weren't as many application or applet examples as I would have liked to see on the disk. The book does go through a few examples which let me rate this one a 3 star.
Book Description
Now updated for the latest release of Java, the Second Edition of Modern Software Development Using Java continues to blaze a new path for today's CS2 students. Tymann and Schneider's contemporary approach focuses on what students need to learn in the CS2 course in order to appreciate what is truly important today in the areas of software design and development. This text covers such current software development ideas as object-oriented design, UML, data structure libraries, net-centric programming, threads, and GUIs, all presented in a way that is fully accessible and motivating. The new edition has been fully revised to take advantage of the new features in Java 5.0, and all material is Java 6.0 compliant.
Average customer rating:
|
Programmieren lernen: Eine grundlegende Einführung mit Java (eXamen.press)
Peter Pepper
Manufacturer: Springer
ProductGroup: Book
Binding: Paperback
Computer Science
| Computers & Internet
| Subjects
| Books
| Artificial Intelligence
| Circuitry
| General
| Human-Computer Interaction
| Information Theory
| Modeling & Simulation
| Research
| Software Engineering
| Systems Analysis & Design
General
| Java
| Programming
| Computers & Internet
| Subjects
| Books
General
| Algorithms
| Programming
| Computers & Internet
| Subjects
| Books
General
| Programming
| Computers & Internet
| Subjects
| Books
General
| Languages & Tools
| Programming
| Computers & Internet
| Subjects
| Books
General
| Computers & Internet
| Subjects
| Books
General
| Applied
| Mathematics
| Science
| Subjects
| Books
General
| Applied
| Mathematics
| Professional Science
| Professional & Technical
| Subjects
| Books
German
| Foreign Language Nonfiction
| Nonfiction
| Subjects
| Books
Nonfiction
| German
| Foreign Language Books
| Specialty Stores
| Books
Professional & Technical
| German
| Foreign Language Books
| Specialty Stores
| Books
All German Books
| German
| Foreign Language Books
| Specialty Stores
| Books
ASIN: 3540327126 |
Book Description
Ziel dieses Buches ist die systematische Vermittlung grundlegender Kenntnisse der Programmierung mittels Java. Dabei werden klassische Konzepte, wie z. B. bedingte Anweisungen, Schleifen und Rekursion durch die wachsenden Anforderungen der betrachteten Problemstellungen sukzessive und gründlich eingeführt.
Im weiteren Verlauf werden u.a. folgende Themen behandelt: Objekte und (generische) Klassen, Kontrollanweisungen und Datenstrukturen, wichtige Algorithmen zum Suchen und Sortieren von Daten sowie für einfache numerische Anwendungen und elementare Graph-Traversierung.
Modularisierungskonzepte und Methoden der nebenläufigen Programmierung mittels Threads, des Exception-Handlings, der Ein- und Ausgabe sowie von graphischen Benutzerschnittstellen runden das Buch ab.
Product Description
This is a NAVAL POSTGRADUATE SCHOOL MONTEREY CA report procured by the Pentagon and made available for public release. It has been reproduced in the best form available to the Pentagon. It is not spiral-bound, but rather assembled with Velobinding in a soft, white linen cover. The Storming Media report number is A938773. The abstract provided by the Pentagon follows: This research focuses on the design of a language-independent concept, Glimpse, for performance debugging of multi-threaded programs. This research extends previous work on Graze, a tool designed and implemented for performance debugging of C++ programs. Not only is Glimpse easily portable among different programming languages: (1) it is useful in many different paradigms ranging from few long-lived threads to many short-lived threads; and (2) it generalizes the concept of intervals over Graze's original definition. Glimpse's portability has been validated by demonstrating its usefulness in performance debugging of both Java programs as well as automatically parallelized FORTRAN programs.
Books:
- Java Message Service (O'Reilly Java Series)
- Java Network Programming, Third Edition
- JavaServer Faces: The Complete Reference (Complete Reference Series)
- Mastering the Trade (McGraw-Hill Trader's Edge)
- MCSA/MCSE Managing and Maintaining a Windows Server 2003 Environment Exam Cram 2 (Exam Cram 70-292)
- MCSA/MCSE Self-Paced Training Kit (Exam 70-270): Installing, Configuring, and Administering Microsoft Windows XP Professional, Second Edition
- MCSA/MCSE Self-Paced Training Kit (Exam 70-350): Implementing Microsoft Internet Security and Acceleration Server 2004 (Pro-Certification)
- MCSE Self-Paced Training Kit (Exams 70-290, 70-291, 70-293, 70-294): Microsoft Windows Server 2003 Core Requirements, Second Edition
- MCSE Self-Paced Training Kit (Exams 70-290, 70-291, 70-293, 70-294): Microsoft Windows Server 2003 Core Requirements, Second Edition
- MCTS Self-Paced Training Kit (Exam 70-431): Microsoft SQL Server 2005 Implementation and Maintenance (Pro-Certification)
Books Index
Books Home
Recommended Books
- Adaptive Filter Theory
- The Measure of a Man: A Spiritual Autobiography
- Interactive Decision Cases for Financial Accounting Cd-Rom: Guided Exploration Llc
- Porn King: The Autobiography of John C. Holmes
- Quantitative Equity Portfolio Management
- The Quickening
- The God Delusion
- The Taxpayer Relief Act 1997: Coopers and Lybrand's Interpretation and Analysis
- Quick Review: Conflict of Laws
- The Conversations at Curlow Creek
Java Generics and Collections
Java(TM) Puzzlers: Traps, Pitfalls, and Corner Cases
Effective Java Programming Language Guide
Java Persistence with Hibernate
Thinking in Java (4th Edition)
