Customer Reviews

Object-Oriented Multithreading Using C++

5 star:		(5)
4 star:		(1)
3 star:		(3)
2 star:		(4)
1 star:		(2)

 

 

There are essentially twelve chapters in the book. The first six and the POSIX specification at the end should not have been included, while the rest should have been written more concisely. In other words, the 500-page book could be boiled down to 150 pages worth reading.

The book is also showing its age. First, the code style is not up to the final C++ standard (say, using such older header files as <algo.h> and <stddef.h> instead of <algorithm> and <cstddef>), nor up to the standard of moden C++ design (see code examples in "Accelarated C++," "Modern C++ Design," and "Efficient C++," etc.). Second, although the term "object-oriented" is part of the book title, the code presented is still a mixed bag of toy C code and C++ classes tied together in long-winded, procedural main() and thread() functions.

In spite of the negatives, one may still learn a few tricks by reading chapters 6-12.

When I purchased this book, I was already familiar with the basics of multithreading and synchronization. My hope was a complete, authoritative manual to help me better develop technique and methodology. In the end I was satisfied that I had learned quite a bit from the authors, but this book is hardly a good value.

First of all, a reader with an extremely rudimentary understanding of multi-tasking will find nothing but review in the first five chapters (out of twelve) of the book. To be fair, the authors state in the preface: "If the reader is familiar with the fundamental C++ class types and the basic operation system concepts needed to understand threads, then the reader can skip Chapter 1 through 4." This is a bit of an understatement, in my opinion. If a reader understands at a basic level what a thread is and how it differs from a process, he or she will find nothing but (tedious) review in the first five chapters. Don't be fooled by the table of contents; any aparently interesting topics in the first five chapters will be covered in such shallow, abstract detail that you will probably get nothing from them. Additionally if you have done any experimentation with threads and understand basically what a mutex/semaphore/event/critical section is you can probably skip chapter six as well.

For me things did not really get interesting or informative until chapter seven at the earliest, maybe even chapter eight. From there on out I would consider the book to be pretty good. Some of it was a little out of place for a book on multithreading. For instance there is a long-winded CSci 101 explanation of what an interface class is at the beginning of chapter seven, which struck me as odd since this is well-covered territory in any OOP C++ book, and familiarity with C++ and OOP in general is a stated pre-condition for reading this book. As for the allegedly poor grammar, I can't honestly say mine is any better so I found it all strangely comforting.

In conclusion, much of this book will be review to the average reader. This fact combined with the high price tag does not make this book a good value. It is nice to have on the shelf because it is pretty comprehensive in content, but keep in mind that much of that content is so fundamentally basic to multithreading that you will find it in many of the more thorough general programming books. If you are looking for money well spent, this probably shouldn't be your choice.

That's the weirdest book ever. It has some rather interesting parts, but those amount to about 10% of the volume. The rest is "fattening up". Why does a book of this type contain an unbearably long coverage of basic C++ concepts is beyond me--a beginner wouldn't buy this book, a user comfortable with C++ doesn't need those endless pages with trivialities. I wish it was a 50-page, thirteen-dollar book (most likely that's why it is so padded--the price is well above $13 <g>.) There are, I want to stress, a few good sections there, but mostly it's vapour. If you're rich--buy it, there's something there, if not, peruse in the bookstore <g>, and put it back on the shelf. I hope it ends up in a bargain section where you could get it--after the price is right...

I read the reviews on this page, and thought I have to add a couple of words to what I've already said. I think the negative reviews are somewhat unfair--there is nothing ungrammatical about the book (definitely not by today's standards of technical writing--go MS Press for the mainstream <g>.) While the book contains much vapour and is wildly overpriced--imho--on the balance isn't bad. I wish it was half-the price and half the size though <g>.

The book is repetitive indeed -- sometimes with paragraphs copied VERBATIM from one chapter to another. The occasional words of wisdom get buried deep in the page fillers. It does get you started on the subject though, albeit slowly.

If you're doing Posix threads in OO and in C++, this book covers the intermediate concepts and builds to more advanced issues. Well thought out. Well designed. If you're doing (or going to do) a distributed, multiThreaded applications, you will thank God every day that you found this book before you started. Unless, of course, you wrote another book on Posix threads. I didn't so I did. :)

The subject of concurrency in software development has taken on particular importance these days due to the emphasis on multitasking in application environments. Users are expecting to be able to perform many tasks at once, and therefore applications must be written that will allow these tasks to be initiated and managed. The strategy for delivering this multitasking is called multithreading and is the topic of this book, and the authors use C++ to implement the needed multithreading. In the book, they discuss mutex objects, anonymous and named pipe objects, thread objects, and container components. They define a concept called incremental multithreading to allow the construction of multithreaded components. The authors do not assume the reader to have any experience in multithreading, but a good background in C++ is assumed. The authors implement the code using POSIX pthreads, and there is an enclosed disk on the book jacket that contains the source code discussed in the book, although only snippets of code are inserted in the book. It is an overview only, and not a textbook, since no problem sets or coding assignments are given in the book. Thus it is not really suitable as a textbook for classroom use, but serves well as a reference.

After a brief review of C++ and OO programming in chapter 1, the authors introduce the concept of a thread and a process in chapter 2. Defining a process as a program in execution, and the environment of a process as a collection of pointers defined by the system, the list the information different types of operating systems give about a process. Processes can be in nine different states with several possible transitions possible between the process states. The authors effectively employ state transition diagrams to illustrate the possibilities. They also discuss in detail the creation of child processes in various operating systems, the differences between synchronous and asynchronous processes, and how processes use available resources.

In chapter 3, a thread is defined as a lightweight process, meaning that the OS does not have quite the burden to manage a thread versus a general process. A multithreaded process then has more than one thread, and the authors give a useful list of the differences between processes and threads. The advantages and disadvantages of threads are the discussed in detail and they classify threads as being sleepers, one shots, anticipating work, and deferring work. Thread control is detailed, along with a discussion of how to prioritize threads. And again, state transition diagrams are used to discuss the dynamics of the changes between different thread states, which are classified as ready, running, and blocked.

Multitasking, which allows more than one process to execute at the same time, and multithreading, which allows a single process to perform many tasks at the same time, are discussed in the next chapter. The advantages of each are discussed, along with scheduling strategies.

The most useful part of the book is the next chapter on interprocess and interthread communication, which are very important in designing concurrent applications. Piping is discussed in detail, along with shared memory and dynamic data exchange. They contrast, effectively using diagrams, the differences between types of communications used by threads, to the types used by processes.

The intricacies and pitfalls behind writing multithreaded applications are discussed in chapter 6 which overviews the cooperation and synchronization of threads. This is where mutexes come in, and the authors do a good job of explaining how they are used.

Interface classes are discussed in more detail in the next chapter, where they are implemented for interprocess communication. The authors could have skipped the generalities on these classes, and instead spend more time on how they assist in multithreading implementations. This chapter finally gets down to a OO approach to programming, and this is followed to a large extent in the next chapter on synchronization objects, where mutex classes are introduced.

Object-oriented multithreaded architectures are discussed in chapter 9, where some multitier approaches are outlined, and a logical PRAM model is discussed. This is followed in the next chapter by how inheritance is used in class hierarchies to implement multithreading. The most useful part of this chapter is the discussion on casting the this pointer, to allow the passing of anything to the thread's main function.

Chapter 11 discusses how C++ objects behave in a multithreaded environment. After a brief review of scoping in C++ and an example, the authors discuss in detail just how objects are created and destroyed in a multithreaded environment. This is followed by a discussion of thread-safe and unsafe functions, and how to use the Standard Template Library in a multithreaded architecture.

In chapter 12, the authors discuss how to test multithreaded applications. The discussion is very general in the first half of the chapter, and not new to anyone who has done software development in a team environment. They do specialize the discussion somewhat to test cases for objects, and discuss the different thread models used when attempting to test multithreaded applications. The discussion however could really be expanded upon, due to its importance. The last chapter of the book is short and merely a wrap-up. The POSIX thread management specifications are given in an appendix to the book.

The authors have done a fairly decent job, but some more advanced examples could have been included along with exercises and projects for the reader to test their understanding. Programming, using multithreading or not, cannot be learned unless code is written and executed by the learner.

This book really has two parts, the first 6 chapters is a fairly simplistic overview of multi-threading concepts, the second half is a rather light-weight treatment of design patterns that are useful in implementing the concepts. I gave this a 3 because as an introduction it isn't too bad if you ignore the C++ coding conventions which are somewhat dated. The code samples are also a bit dangerous since some compilers and linkers will get confused by the use of <algo.h> and <algo> in the same compilation unit.

If this was 1997 this book would get 4 or 5 stars, although the concepts are good, the code is now a bit archaic making it a three.

I thoughly enjoyed this book. The illistrations and examples matched much of my experiences and aided my thoughts. This would be an excellent book for a college senior or as an overview of the principles of multithreading in multiple OS's. For people that haven't dealt with OS's except Windows, this might tend to just confuse rather than enlighten. I thought the writing flowed well and I could read large sections without getting tired or bored.

This book offers an excellent treatment of the problems associated with multithreading and the code to work around them. It is an invaluable book to which one will often refer. For the serious reader, one who is interested in the details as this book is very thorough.