Concurrency provides a thoroughly updated approach to the basic concepts and techniques behind concurrent programming. Concurrent programming is complex and demands a much more formal approach than sequential programming. In order to develop a thorough understanding of the topic Magee and Kramer present concepts, techniques and problems through a variety of forms: informal descriptions, illustrative examples, abstract models and concrete Java examples. These combine to provide problem patterns and associated solution techniques which enable students to recognise problems and arrive at solutions.
New features include: New chapters covering program verification and logical properties. More student exercises. Supporting website contains an updated version of the LTSA tool for modelling concurrency, model animation, and model checking. Website also includes the full set of state models, java examples, and demonstration programs and a comprehensive set of overhead slides for course presentation.
User review
Who needs all the pages?
I was very annoyed with this purchase. I received a product that one had the cover put on backwards and then two was missing pages. Page 125, blank page, 127. mmm to bad the teacher said the answer was on page 126. And its not that its one or two pages, it is several pages (at least 25) throughout the book.
First problem I have had with amazon, but its a big one. Waste of my money to purchase an incomplete book.
User review
Good book
This book was a required text in a graduate course in Software Engineering that I had taken. As many other reviewers said, it is solid on theory but lacks from a practical standpoint. None of the new threading features in J2SE 5 are covered which is a significant drawback. For beginners to threading, this book does a decent job of illustrating some of the issues/problems that will be encountered and potential ways to solve them. The book's website has applets that allows the reader to see some of the problems in action which is nice. However, if you are already working in the industry and you need to use threads, a better choice would be Java Concurrency In Practice by Brian Goetz.
User review
Why this book is important.
There are several levels of understanding of practical concurrency.
At first you have a palette of tool in your language and you delve into creating multithreaded programs. Hopefully, soon you realize that you need to protect concurrently accessed data from corruption so you start to use low level protection operations to gate access to the data. Many programmers, who consider themselves adept at multi-threaded coding, never advance beyond this point.
Next you encounter race and deadlock issues. These can not be addressed by protecting your data because they are flaws in the state logic of your machine. You can address them with careful ordering of your operations, there are tools to help with detection and elimination and finally picking higher level concurrency constructs can help reduce these. Many programmers use these techniques but the same techniques are frequently an invitation to greater complexity without solving the underlying issue.
The next level, and I am not sure if it is the last, is when you realize that some form of state machine representation is the only consistent way to produce a safe concurrent program that does what you want. It has more to do with a clear model of the operations then it does with any form of concurrency construct. Even with the latest Java 5 threading and concurrency tools you still would need to model to know if your case effectively fits with the construct provided.
Okay, that was a long winded way of explaining why some people do not get this book. It is an important book but it is not a perfect book. I found the first half to be a rather slow introduction to concurrent statefulness. The cases covered are very basic, like Dining Philosophers. I enjoyed the second half more and found some useful information. The dependence on the LTSA modeling methods/tools I found cumbersome and of questionable usefulness. I think just UML Statecharts would have been more useful if less precise/provable.
The book explicitly uses only the lowest level of threading tools from Java, which they then use to build up to higher level constructs as illustration of modeling.
It is very clearly a mid-level undergraduate text book for Computer Science and it reads like it. If you are most interested in the current mechanics of threading under Java this would be a very bad first choice.
User review
Concurrency fundamentals using a model-based approach
I have used the first edition of this textbook in a course on concurrent and real-time systems at The University of Queensland since 2001, and I am looking forward to using the second edition from next year. This textbook is an excellent introductory textbook to concurrency (in Java) in that it focuses on the foundations of concurrency, rather than the latest features and tricks in programming languages to make concurrent programs as efficient as possible.
My experience with teaching concurrent programming is that students find it difficult to write concurrent programs (even simple ones) that are error-free and anecdotal evidence from colleagues in industry indicates that the situation is not much different for many experienced programmers. As such, I believe that we should focus on the fundamentals when we teach concurrent programming and make sure that the students understand these before we move on to more advanced topics.
The model-based approach followed by the authors is also refreshing. While I don't believe that the model-based approach will eliminate the need for other V&V approaches such as testing, it is clear that models are and will play an increasingly important role in software engineering. The book introduces models of concurrent systems with a specific purpose in mind, provides tool support to analyse the models for properties of interest, and (perhaps most importantly) applies the model-based approach consistently throughout the book. Most of the extensions in the second edition are related to the model-based approach, including new chapters on program verification and on specifying and validating logical properties.
In summary, I highly recommend this book as an introductory text on concurrent programming, especially for those people interested in the rapidly evolving area of model-based development. If you are interested in the latest concurrency features of the Java programming language or how to write the most efficient concurrent programs, you may need to purchase other books (such as the ones by Doug Lea or Brian Goetz) as well.
User review
Too dependent on FSP, LTS, and LTSA
I'm using the text this semester in my course, and while it presents the material in a clear enough way, I find the authors' dependence on the LTS/FSP language to model concurrency examples (and running these on a simulator - LTSA) adds just one extra layer my students have to master. The simulator does not include decent documentation (I've been trying to run a particular trace that the text suggests doing, but doesn't say how to - and I haven't found how to do it.) The FSP language takes a bit of effort to master; the text does have three appendices on FSP, but again, that's an extra layer the students have to understand.
Most of the text uses the FSP language to present models of processes. Finite state diagrams are also plentiful and add to the visual presentation. Sample Java code is also woven into the discussions - these graphical Java applets do have a `wow` factor. I think my reservations have to do with certain topics that could be easily presented but are made more complicated with the addition of elaborate FSP models that can slow down the reader. At times the material gets too far down into nuts and bolts when a more general view can work just as well.
