Free Downloads Multithreading Applications In Win32: The Complete Guide To Threads
Using multiple threads, you can create high-performance servers, build extensions for Internet servers, take advantage of multiprocessor systems, build sophisticated objects in OLE and COM, and improve application responsiveness. Writing such software requires more than theory and a reference manual; it requires a comprehensive understanding of how everything fits together and a guide to what works and what doesnt. Multithreading is supported under Windows NT and Windows 95 and later through the Win32 API, but coverage of this important topic has been sporadic and incomplete until now. In Multithreading Applications in Win32, with just enough theory and lots of sample code, Jim Beveridge and Bob Wiener show developers when, where, and how to use multithreading. Included in the book are: Internet development examples, including ISAPI and WinSock. Hands-on coverage of how to use threads and overlapped I/O for server development. How to use the C run-time library and MFC in a multithreaded environment. Examples in C and C++. Comparisons to UNIX for developers transitioning from UNIX to Win32. The enclosed CD-ROM includes the code and sample applications from the book, including code t
Paperback: 400 pages
Publisher: Addison-Wesley Professional (December 29, 1996)
Language: English
ISBN-10: 0201442345
ISBN-13: 978-0201442342
Product Dimensions: 7.4 x 0.9 x 9 inches
Shipping Weight: 1.4 pounds (View shipping rates and policies)
Average Customer Review: 4.4 out of 5 stars See all reviews (26 customer reviews)
Best Sellers Rank: #453,525 in Books (See Top 100 in Books) #2 in Books > Computers & Technology > Programming > APIs & Operating Environments > Win32 API #135 in Books > Computers & Technology > Hardware & DIY > Personal Computers > PCs #159 in Books > Computers & Technology > Business Technology > Windows Server
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.
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.
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.
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 [...]- Click on the Downloads tab- Click on the words "CD Contents"
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 here2. 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 had had the level.
Multithreading Applications in Win32: The Complete Guide to Threads Modern Multithreading: Implementing, Testing, and Debugging Multithreaded Java and C++/Pthreads/Win32 Programs Real-Time Embedded Multithreading Using ThreadX Pro Multithreading and Memory Management for iOS and OS X: with ARC, Grand Central Dispatch, and Blocks Multithreading in C# 5.0 Cookbook Advanced Windows: The Developer's Guide to the WIN32 API for Windows NT 3.5 and Windows 95 Pcm Visual Basic Programmers Guide to the WIN32 API Twisted Threads: Mainely Needlepoint Mystery Series #1 Programming with POSIX Threads Programming With Threads Programming with UNIX Threads Win32 Programming (Addison-Wesley Advanced Windows Series)(2 Vol set) Win32 Perl Programming: The Standard Extensions (2nd Edition) Dan Appleman's Win32 API Puzzle Book and Tutorial for Visual Basic Programmers Perl Resource Kit Win32 Edition Los Tomos de Delphi: API Gráfico Win32 (Spanish Edition) Windows Internals, Part 1: System architecture, processes, threads, memory management, and more (7th Edition) DIY Bride: Perfect Invitations: create your dream wedding on a budget (Threads Selects) Threads of the Covenant: The Jews of Red Jacket The Shoshoni Concept of God (Theological Threads Book 3)
