Customer Reviews

Multithreading Applications in Win32: The Complete Guide to Threads

5 star:		(14)
4 star:		(6)
3 star:		(3)
2 star:		(0)
1 star:		(0)

 

 

This book has been essential for writing our multi-threading, commercial apps. The material begins by providing an explanation for why threads are useful, and follows with a thorough explanation of how to synchronise the activities of many threads. Synchronisation is perhaps the biggest obstacle to producing a working multi-threaded app. I found the most useful chapter to be 10: Threads in MFC. This shows how to create worker threads, derived from CWinThread, instead of calling AfxBeginThread(). This allows you to design classes that represent your threads in a more object-oriented way. The book is clearly typeset, with good explanations of both good technique and the common mistakes that can easily be made when starting out. The FAQ section also helped with common problems that turned up.

I recommend a good understanding of C++ to get the most out of this book, though this isn't essential.

In my opinion, this is *the* book for understanding the theory and practice involved in Multithreaded apps for Win 32. Fortunately, I found this book before writing any multi-threaded apps and I cannot recommend it enough!

I just started reading the book and the content is presented in a nice, progressive manner building up from the simple to the more complex. I just hope the author's discussions of threading is better than his coding. e.g. The sample code at the end of the second chapter doesn't do a good job of cleaning up - the font created is never destroyed and the bitmap created should be destroyed if printing to the printer. Also, most authors/publishers have an errata page for their books but none can be found for this one so you're left on your own to discover any bugs/typos.

This material is still relevent, even when using .NET. The discussion of Win32 multithreading transcends any particular development environment used with a Windows 32 bit environment.

The key idea behind this book is getting correct, reproducible results with windows multithreaded applications. Multithreaded applications are very hard to get right and even harder to properly test. The author explains the many sources of problems and how to avoid them.

In order to understand this book's code samples, you will have to understand the Win32 API and code written in Visual C++ for Windows NT. It is important to see examples of these concepts in code.

It's old, and the sample code has some flaws, but the text is so damn clear that this book is a must buy. Nothing important is skimped, nothing is confused, nothing is concealed behind excess verbage. Both the Windows threading api and the deeper principles behind designing threaded apps are dealt with more than competently. A star taken away for some buggy sample code, but a star added for wrting clearly about threading, an area that's notoriusly hard to write about or explain well.

I have to say that this is a good book as other reviewers have said.

But I have to point out that there are some inconsistent parts in the book. I've tried to find errota on Addison Wesley's web site with no success.

1. Chapter 7, Data Consistency, Sample code "readwrit" which didn't give the consistent results if running the program several times. If letting the sample search pNode in the following text, it will give 0, 1, 2 findings from time to time, it never gives 5. It gives me the impression that multithreading has no accuracy in the beginning. // start here * pList, pNode * pNode, pNode * Demonstrates an implementation of the * Readers/Writers algorithm. This version * pList, pNode * pList, pNode * pList, pNode // end here

2. Chapter 2, the source code shown on book (p63) is not correct as the threads (hThrds[slot]) were not closed. The file on CD is correct.

3. Building DLLs as given in p306. The authors pointed it out themselves that the sample code is not a DLL. For a novice, how can you expect him/her to generate correct codes? They need every possible source to figure out their problems. In fact I have a great pain when I read this part as this is exactly what I need. Maybe it will cost authors only several hours at most, but it'll cost readers weeks.

4. There are some other printing errors.

Although pointed above, I still like the book. It does provide extensive topics regarding to multi threading and many concise samples. You cannot find these from Petzold's or Prosise's books (They are excellent in general). Read this book with Jeffrey Richter's Advanced Windows (3rd Ed) will help readers to understand more about Win32 programming.

I would have rated this book 4.5 stars if amazon had had the level.

This is a very focused book. I found it a good companion book to other Windows programming books. It doesn't try to go into areas outside of it's scope like discussing MFC programming or C++ programming. If you want to know about threads and how to program using the WIn32 threading model then get this book.

Excellent reference on writing, debugging, and maintaining multithreaded code in Windows.

In my day job, I have to maintain and extend a heavily multithreaded service used with a fingerprint sensor. The original authors didn't quite have a handle on C++ or multithreading, and we've had a number of difficult bugs to track down and fix. This book, despite its age, is an excellent reference on multithreading in Windows, and I agree with some other reviewers that it should be mandatory reading for anyone working on multithreaded code.

For those like me who got a copy of this book without the CD, here's how to get it, courtesy of the author:

You can get the source code as follows:
- Go to http://www.awprofessional.com/bookstore/product.asp?isbn=0201442345&rl=1
- Click on the Downloads tab
- Click on the words "CD Contents"

It is a good book on Windows multithreading. Synchronization, overlapped files, C++ multithreading, and MFC multithreading are clearly explained. You will find this book very good for you if you are a beginner in multithreading. However, it is clear that you should buy other book like Butenhof's book. You need other book because the reviewed one has funny things in it when it explains about the real application of multithreading programs. Can you imagine a multithreading book discourage its readers to write a multithreading application ? For example, he explained that it was difficult to write a multithreading book because maybe the existing library you have bought from other vendors might not be thread-safe..., so what you should do? This book does not give the answer

This book explains every aspects of a multithreaded application. You don't have to buy a few books before you can grasp the whole concept of multithreading. If you're new to this area, I highly recommend this book as your standard text.

However, this book was written in 1996, you can only find one chapter on MFC. Hope Jim could cover more on MFC & VC++ in the next edition.

While the subject matter of this book is not for the novice, this is a must-read for anyone developing or planning to develop multi-threaded applications. I have been developing multi-threaded applications for several years and I found this book to be full of useful examples and insights on threading. It was clear, to the point, and easy to read.