Wander - Shop now
Buy new:
-27% $93.06
FREE delivery May 16 - 21 to Nashville 37217
Ships from: DeckleEdge LLC
Sold by: DeckleEdge LLC
$93.06 with 27 percent savings
List Price: $127.95
FREE delivery May 16 - 21 to Nashville 37217. Details
Or fastest delivery May 15 - 19. Details
Usually ships within 6 to 7 days
$$93.06 () Includes selected options. Includes initial monthly payment and selected options. Details
Price
Subtotal
$$93.06
Subtotal
Initial payment breakdown
Shipping cost, delivery date, and order total (including tax) shown at checkout.
Ships from
DeckleEdge LLC
DeckleEdge LLC
Ships from
DeckleEdge LLC
Returns
30-day refund/replacement
30-day refund/replacement
This item can be returned in its original condition for a full refund or replacement within 30 days of receipt. You may receive a partial or no refund on used, damaged or materially different returns.
Read full return policy
Payment
Secure transaction
Your transaction is secure
We work hard to protect your security and privacy. Our payment security system encrypts your information during transmission. We don’t share your credit card details with third-party sellers, and we don’t sell your information to others. Learn more
$13.91
Excellent condition, dust jacket included when applicable, no markings in text. Excellent condition, dust jacket included when applicable, no markings in text. See less
FREE delivery Tuesday, May 13 to Nashville 37217. Details
Or fastest delivery May 8 - 12. Details
Only 1 left in stock - order soon.
$$93.06 () Includes selected options. Includes initial monthly payment and selected options. Details
Price
Subtotal
$$93.06
Subtotal
Initial payment breakdown
Shipping cost, delivery date, and order total (including tax) shown at checkout.
Access codes and supplements are not guaranteed with used items.
Ships from and sold by Books-R-Keen.
Kindle app logo image

Download the free Kindle app and start reading Kindle books instantly on your smartphone, tablet, or computer - no Kindle device required.

Read instantly on your browser with Kindle for Web.

Using your mobile phone camera - scan the code below and download the Kindle app.

QR code to download the Kindle App

Follow the author

Richard H. Carver
Follow
Something went wrong. Please try your request again later.

Modern Multithreading : Implementing, Testing, and Debugging Multithreaded Java and C++/Pthreads/Win32 Programs 1st Edition

by Richard H. Carver (Author), Kuo-Chung Tai (Author)
4.2 out of 5 stars 12 ratings
{"desktop_buybox_group_1":[{"displayPrice":"$93.06","priceAmount":93.06,"currencySymbol":"$","integerValue":"93","decimalSeparator":".","fractionalValue":"06","symbolPosition":"left","hasSpace":false,"showFractionalPartIfEmpty":true,"offerListingId":"VpgwHVSFdvLThn5CiP09xsMbL290PEmQVQzjoYdBRoDbFzk4wqkzIP2hFm0JMEcLc9OTUZ%2B1UAkr18FgJb0TRr3ywYGDEkN%2B6%2BdtXbmyGlv6lbPo6Z64hgFKvYAgC563XDetEqB2cVGlqV2a9i7GBMq23TLsLoT497qlfdMlV1wDHcuKpdjQXw%3D%3D","locale":"en-US","buyingOptionType":"NEW","aapiBuyingOptionIndex":0}, {"displayPrice":"$13.91","priceAmount":13.91,"currencySymbol":"$","integerValue":"13","decimalSeparator":".","fractionalValue":"91","symbolPosition":"left","hasSpace":false,"showFractionalPartIfEmpty":true,"offerListingId":"VpgwHVSFdvLThn5CiP09xsMbL290PEmQQse6uAWvPStugY6DPMr%2FwVHZIQUvql2%2B9ZP4FLzSBwkWutl7UEbm14479FsG5yNm8a5Cmr0i5bcmMWBzUgukSnnGg%2BBhlJSzjE%2BvbqOgWlcGFG477KBZ43y0tJz4YhDFriKxuhFGdRRFhYQ%2Btp4URQ%3D%3D","locale":"en-US","buyingOptionType":"USED","aapiBuyingOptionIndex":1}]}

Purchase options and add-ons

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.
Read more
Previous slide of product details
  1. ISBN-10
    0471725048
  2. ISBN-13
    978-0471725046
  3. Edition
    1st
  4. Publisher
    Wiley-Interscience
  5. Publication date
    October 19, 2005
  6. Language
    English
  7. Dimensions
    6.22 x 0.93 x 9.31 inches
  8. Print length
    480 pages
Next slide of product details

Editorial Reviews

Review

"…an excellent work on concurrent programming, examining languages and libraries for developing multithreaded programs." (CHOICE, April 2006)

From the Inside Flap

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.

Product details

  • Publisher ‏ : ‎ Wiley-Interscience; 1st edition (October 19, 2005)
  • Language ‏ : ‎ English
  • Paperback ‏ : ‎ 480 pages
  • ISBN-10 ‏ : ‎ 0471725048
  • ISBN-13 ‏ : ‎ 978-0471725046
  • Item Weight ‏ : ‎ 1.45 pounds
  • Dimensions ‏ : ‎ 6.22 x 0.93 x 9.31 inches
  • Customer Reviews:
    4.2 out of 5 stars 12 ratings

About the author

Follow authors to get new release updates, plus improved recommendations.
Richard H. Carver

Richard H. Carver

Brief content visible, double tap to read full content.
Full content visible, double tap to read brief content.

Discover more of the author’s books, see similar authors, read book recommendations and more.

Customer reviews

4.2 out of 5 stars
12 global ratings

Review this product

Share your thoughts with other customers
Write a customer review

Top reviews from the United States

  • John A. Perez
    5.0 out of 5 stars An excellent treatise on Multi-Threading - for the professional
    Reviewed in the United States on February 17, 2009
    Verified Purchase
    I can't emphasize how excellent this book is. It not only goes to great lengths to explain the intricacies of how MultiThreading works, but it also cleverly shows how things can go wrong. It also provides algorithms for synchronizing events without creating deadlocks.

    Highly recommended.
    3 people found this helpful
    Helpful
     Report
  • Jose R. Castillo H
    4.0 out of 5 stars quite a god book
    Reviewed in the United States on November 25, 2007
    Verified Purchase
    this book is awesome and also very clear to understand, it help you fix very common mistakes with real life examples. all the code is focused on a common classes between C++/java, the only cons is this book don't use linux pthreads instead use win32 version of pthreads so be carefull because the examples on their website won't compile in linux without adjustment.
    3 people found this helpful
    Helpful
     Report
  • Dayle L. Flowers
    5.0 out of 5 stars Excellent Book If You Have Atleast a Basic Knowledge of Threading
    Reviewed in the United States on November 9, 2007
    This book is simply excellent. I have already completed my bachelors degree in Computer Science, which means I only had a basic understanding of threading from my Distributed Computing class. So, I knew a whole bunch of thread jargon and slightly understood how threads are created and what the critical section problem is, as well as a basic understanding of how semaphores can solve the problem. Beyond that, the book has taught me what goes on behind the scenes of thread creation and why critical sections can be so complicated. The average Computer Science student is not interested in how it works behind the scenes, only how to make it work for their current needs. This book, while useful to a more adept coder, will not quickly and easily fulfill that requirement. It is definitely geared toward those that are really serious about multithreading and intend to test/use their threading knowledge over and over again. If that is you and you don't really understand threading too well, this book can take you from novice to expert in only a few months.

    I'd definitely recommend it to my co-workers!
    5 people found this helpful
    Helpful
     Report
  • P. E. Chaintreuil
    3.0 out of 5 stars Like a grad. level paper: Helpful, if you can read it.
    Reviewed in the United States on October 5, 2006
    Verified Purchase
    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.
    9 people found this helpful
    Helpful
     Report
  • Indikos
    2.0 out of 5 stars You will be better served elsewhere
    Reviewed in the United States on April 28, 2008
    As a Java engineer, I cannot really recommend this book. While the authors are definitely knowledgeable about their subject, they do not do a good job in communicating their knowledge to a reader. The book reads like a doctoral thesis, poorly organized, not well laid out. Brian Goetz book on Concurrency is a much better book.
    9 people found this helpful
    Helpful
     Report
  • Cumhur Guzel
    3.0 out of 5 stars Subject are not presented well
    Reviewed in the United States on June 17, 2008
    Even though title suggests it is 'modern multithreading', this book reiterates typical multithreading issues. However subjects addressed are not presented well enough and code snippets are not explained properly.
    Helpful
     Report
  • Ray
    3.0 out of 5 stars Concepts are nice but reading it is terse
    Reviewed in the United States on August 13, 2007
    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
    2 people found this helpful
    Helpful
     Report

Top reviews from other countries

  • Jsh
    3.0 out of 5 stars Tough read but interesting ideas
    Reviewed in the United Kingdom on July 19, 2007
    Verified Purchase
    I bought this book because of the "Testing and Debugging" in the sub-title as this is an area that other books on multi-threading tend to skip.

    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 (and this is the least significant, but one for the publisher to be aware of) 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 (because of writing style, not difficulty of content) 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. Terse (but worth persevering).

    The third negative, is that the code samples are described by the authors 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".

    [Note added April 2009] Intel sell a tool called Intel ThreadChecker which does detection of race conditions very successfully. Rather than add extra complexity in your own code to check for such issues, you may prefer to simply use ThreadChecker.
    Report