What do you think?
Rate this book
Concurrent Systems (2nd Edition) (International Computer Science Series) by J. Bacon
This book presents a modern approach to software systems, ideally suited to the needs of today's students and programmers. It focuses on those concepts in concurrency that play a vital role in the design of operating systems, database systems, distributed systems and communication networks.
In the second edition, an object-oriented paradigm is used as a unifying framework, the principles of concurrency are developed from simple uniprocessor systems through to modern multiprocessor systems with shared memory or in distributed enviroments. The evolution of the concepts leads naturally to transactions, concurrency control and recovery for distributed databases.
Contents (Second edition)
Preface to the second edition.
1.. Examples and requirements
PART BACKGROUND AND FUNDAMENTALS
2. System structure and dynamic execution
3. The hardware interface, I/O and communications
4. Support for processes
5. Fundamentals of distributed systems
6. Memory management
7. File management
PART SINGLE CONCURRENT ACTIONS
8. System structure
9. Low-level synchronization Implementation
10. Low-level Use in systems and languages
11. Language primitives for shared memory
12. IPC and system structure
13. IPC without shared memory
14. Crash resilience ad persistent data
15. Distributed IPC
PART CONCURRENT COMPOSITE ACTIONS
16. Decomposable abstract operations
17. Resource allocation and deadlock
18. Transactions
19. Concurrency control
20. Recovery
21. Logging and shadowing for crash resilience
21. Distributed transactions
22. Distributed computations
PART SYSTEM CASE STUDIES
23. UNIX
24. Mach and CHORUS
25. Windows NT
26. CORBA and Java
27. Transaction processing monitors and systems
EVOLUTION OF COMPUTER SYSTEMS
Bibliography
Glossary
Author index
Subject index
In the second edition, an object-oriented paradigm is used as a unifying framework, the principles of concurrency are developed from simple uniprocessor systems through to modern multiprocessor systems with shared memory or in distributed enviroments. The evolution of the concepts leads naturally to transactions, concurrency control and recovery for distributed databases.
Contents (Second edition)
Preface to the second edition.
1.. Examples and requirements
PART BACKGROUND AND FUNDAMENTALS
2. System structure and dynamic execution
3. The hardware interface, I/O and communications
4. Support for processes
5. Fundamentals of distributed systems
6. Memory management
7. File management
PART SINGLE CONCURRENT ACTIONS
8. System structure
9. Low-level synchronization Implementation
10. Low-level Use in systems and languages
11. Language primitives for shared memory
12. IPC and system structure
13. IPC without shared memory
14. Crash resilience ad persistent data
15. Distributed IPC
PART CONCURRENT COMPOSITE ACTIONS
16. Decomposable abstract operations
17. Resource allocation and deadlock
18. Transactions
19. Concurrency control
20. Recovery
21. Logging and shadowing for crash resilience
21. Distributed transactions
22. Distributed computations
PART SYSTEM CASE STUDIES
23. UNIX
24. Mach and CHORUS
25. Windows NT
26. CORBA and Java
27. Transaction processing monitors and systems
EVOLUTION OF COMPUTER SYSTEMS
Bibliography
Glossary
Author index
Subject index
Mass Market Paperback
First published January 1, 1992
1 person is currently reading
15 people want to read
About the author
Jono Bacon
12 books36 followersJono Bacon (full name Jonathan Edward James Bacon) is a writer and software developer based in the United Kingdom. Bacon started his work with the Linux community when he created the UK Linux website, Linux UK. When he left this project he moved on to join the KDE team, where he created the KDE::Enterprise website and KDE Usability Study. He has also been involved with helping charities using free software, as well as shaving off his beard for Amnesty International at LugRadio Live 2006. He was a participant in LugRadio and founded Wolverhampton Linux Users' Group. Additionally, he has created a heavy rock version of the Free Software Song.
Ratings & Reviews
Friends & Following
Create a free account to discover what your friends think of this book!
Community Reviews
Displaying 1 - 2 of 2 reviews
September 25, 2023
A very interesting book, especially for the time in which it was written. Its originality lies in two aspects. The first is its focus on the key problems and proposed technological solutions to taking advantage of concurrency in monoprocessor and multiprocessor systems at the operating systems, programming language run-time systems, database and distributed systems levels. The second is in its use of basic object-oriented terminology -innovative in its time but nowadays taken for granted.
Jean Bacon shows how the need for concurrency arose from the pressure for computers to interface efficiently with other devices and thus manage exceptions and interruptions on a monoprocessor system. This, together with having to deal with multiple users concurrently in timesharing systems, is an important factor in the development of the concept of process and its supporting mechanisms: scheduling, events, and interprocess communication starting with signal and wait. The growing complexity and requirements for memory and file management plays another key role in the development of concurrency.
The first part of the book is a little slow in getting off the ground. However, she comes into her own in Part II.
Bacon's masterful treatment of the evolution of what she calls “single concurrent actions” -Part II of the book- , clearly showing the advantages and failcoming different proposals to design and implement their control and management, their (partial) successes and shortcomings makes reading the book a worthwhile endeavour. She covers the different flavours and granularities of threads and their relationship to more heavyweight processes or tasks in both shared memory and distributed multiprocessor systems. She covers the implementation of low-level (kernel or operating system) synchronization primitives as wll as language primitives to achieve exclusive access to shared data such as, in the first case, event signal and wait, and semaphores and, in the latter case, critical regiones, monitors, per-object exclusion, path expressions and, active objects. Later she devotes equal time to distributed interprocess communications, looking at client-server models, synchronous and asynchronous communication, and remote procedure calls. Along the ways she covers classical problems and solutions such as the N-process mutual exclusion protocol of Eisenberg and McGuire, bakery algorithms, the producer-consumer bounded buffer problem, the multiple readers, single writer problem. She also clearly points out the shortcomings in some of the proposals for real-time systems. Bacon rounds up this second part of the book by studying crash resilience, a key topic she analyzes as to its impact on interprocess communication, moving on to fundamental concepts and mechanisms for database systems such as idempotent operations and atomic operations as well as the use of logging and shadowing to implement atomic operations.. In this part, some explanations are not always as clear as I would have liked and her decision to skip formal reasoning methods on correctness, safety and liveness, while understandable in terms of space, does tend to a certain amount of proof by hand-waving. Even though I read the second edition of the book, I believe a couple of the more slippery algorithms contain some errors -although I admit I may be mistaken.
Having covered single concurrent actions in the second part of the book, the third part of the book is devoted to concurrent composite actions. Thus, for starters it covers topics such as resource allocation, livelock and (briefly) starvation, conditions for deadlock, the dining philosophers problem, algorithms for deadlock prevention and avoidance. Again the lack of formal reasoning methods is sorely missed for some delicate explanations. A whole chapter is dedicated to transactions and I'm afraid Bcon rather lost me in her attempt to describe serializability particularly in her use of dependency graphs. This chapter is followed by chapters on concurrency control (two phase locking, time-stamp ordering and optimistic concurrency control), two chapters on recovery (logging and shadowing for crash resilience) and a chapter on process groups (leadership election), methods to ensure consistency of data replicas, ordering message delivery (vector clocks) and distributed N-process mutual exclusion.
In Part IV, the author includes several case studies, namely Unix, Mach and CHORUS (as examples of microkernel architecture), Windows NT, CORBA and Java middleware, and a final chapter on transaction processing monitors and systems. The chapter of Unix is somewhat disappointing as a case study in its own right but should be read as necessary reading for the followig chapter on microkernel architecture. I particularly liked the chapter on Mach and Chorus as well as the chapter on transaction processing systems (TPS). It is quite stunning to see how much more demanding TPS have become in the intervening years.
Although the back cover of the book claims that it covers the role of concurrency in communication systems as well, such coverage is minimal at best.
The exercises included at the end of each chapter are somewhat problematic. Some exercises are very straightforward (this is the case for several of the case studies on specific operating systems) but in other chapters (particularly in parts two and three) it seemed to me there is a large gap between what is actually covered and the questions asked, which sometimes to be research questions.
I bought the second edition of this book around the year 2000 when I was about to look more deeply into parallel computing, but never got around to reading it until 2023, years after I left working on parallelism. A key question for any 2023+ reader is how outdated the book may be and whether it is worth reading it, twenty five years after it was written. The author wrote a third edition of this book in 2002 and I wonder what she changed in it. Although I liked her chapter on microkernel operating systems, I feel it would have to be considerably updated, and according to Andrew Tanenbaum's claim in his most recent (2023) book on operating systems, CORBA is now obsolete. Quite honestly I would not recommend anyone, like me, trying to read a 1998 book as a stepping stone from, say 1985 to the current day. I would recommend first reading a textbook like Tanenbaum's 2023 book and then deciding whether it is worthwhile going to Bacon's book. I plan to follow my own recommendation and read Tanenbaum's book in the near future and then come back to this review to put it into perspective. In spite of these comments, I must admit I enjoyed the unusual but logical transdisciplinary flavor of Bacon's book, – I loved the way it linked and integrated key process-related concepts in operating systems, programming languages, database systems, and transaction processing systems in the context of distributed system needs. It is a shining example of a Computer Engineering viewpoint on a very important topic and, in this sense, for me is comparable to Larry Peterson and Bruce Davies's brilliant (and roughly contemporary -1996) Computer Networks: A Systems Approach. For the record, I also believe Bacon's book is a deeper, broader and more reflective look at some of the issues covered by Tanenbaum's 1994 Distributed Operating Systems.
Jean Bacon shows how the need for concurrency arose from the pressure for computers to interface efficiently with other devices and thus manage exceptions and interruptions on a monoprocessor system. This, together with having to deal with multiple users concurrently in timesharing systems, is an important factor in the development of the concept of process and its supporting mechanisms: scheduling, events, and interprocess communication starting with signal and wait. The growing complexity and requirements for memory and file management plays another key role in the development of concurrency.
The first part of the book is a little slow in getting off the ground. However, she comes into her own in Part II.
Bacon's masterful treatment of the evolution of what she calls “single concurrent actions” -Part II of the book- , clearly showing the advantages and failcoming different proposals to design and implement their control and management, their (partial) successes and shortcomings makes reading the book a worthwhile endeavour. She covers the different flavours and granularities of threads and their relationship to more heavyweight processes or tasks in both shared memory and distributed multiprocessor systems. She covers the implementation of low-level (kernel or operating system) synchronization primitives as wll as language primitives to achieve exclusive access to shared data such as, in the first case, event signal and wait, and semaphores and, in the latter case, critical regiones, monitors, per-object exclusion, path expressions and, active objects. Later she devotes equal time to distributed interprocess communications, looking at client-server models, synchronous and asynchronous communication, and remote procedure calls. Along the ways she covers classical problems and solutions such as the N-process mutual exclusion protocol of Eisenberg and McGuire, bakery algorithms, the producer-consumer bounded buffer problem, the multiple readers, single writer problem. She also clearly points out the shortcomings in some of the proposals for real-time systems. Bacon rounds up this second part of the book by studying crash resilience, a key topic she analyzes as to its impact on interprocess communication, moving on to fundamental concepts and mechanisms for database systems such as idempotent operations and atomic operations as well as the use of logging and shadowing to implement atomic operations.. In this part, some explanations are not always as clear as I would have liked and her decision to skip formal reasoning methods on correctness, safety and liveness, while understandable in terms of space, does tend to a certain amount of proof by hand-waving. Even though I read the second edition of the book, I believe a couple of the more slippery algorithms contain some errors -although I admit I may be mistaken.
Having covered single concurrent actions in the second part of the book, the third part of the book is devoted to concurrent composite actions. Thus, for starters it covers topics such as resource allocation, livelock and (briefly) starvation, conditions for deadlock, the dining philosophers problem, algorithms for deadlock prevention and avoidance. Again the lack of formal reasoning methods is sorely missed for some delicate explanations. A whole chapter is dedicated to transactions and I'm afraid Bcon rather lost me in her attempt to describe serializability particularly in her use of dependency graphs. This chapter is followed by chapters on concurrency control (two phase locking, time-stamp ordering and optimistic concurrency control), two chapters on recovery (logging and shadowing for crash resilience) and a chapter on process groups (leadership election), methods to ensure consistency of data replicas, ordering message delivery (vector clocks) and distributed N-process mutual exclusion.
In Part IV, the author includes several case studies, namely Unix, Mach and CHORUS (as examples of microkernel architecture), Windows NT, CORBA and Java middleware, and a final chapter on transaction processing monitors and systems. The chapter of Unix is somewhat disappointing as a case study in its own right but should be read as necessary reading for the followig chapter on microkernel architecture. I particularly liked the chapter on Mach and Chorus as well as the chapter on transaction processing systems (TPS). It is quite stunning to see how much more demanding TPS have become in the intervening years.
Although the back cover of the book claims that it covers the role of concurrency in communication systems as well, such coverage is minimal at best.
The exercises included at the end of each chapter are somewhat problematic. Some exercises are very straightforward (this is the case for several of the case studies on specific operating systems) but in other chapters (particularly in parts two and three) it seemed to me there is a large gap between what is actually covered and the questions asked, which sometimes to be research questions.
I bought the second edition of this book around the year 2000 when I was about to look more deeply into parallel computing, but never got around to reading it until 2023, years after I left working on parallelism. A key question for any 2023+ reader is how outdated the book may be and whether it is worth reading it, twenty five years after it was written. The author wrote a third edition of this book in 2002 and I wonder what she changed in it. Although I liked her chapter on microkernel operating systems, I feel it would have to be considerably updated, and according to Andrew Tanenbaum's claim in his most recent (2023) book on operating systems, CORBA is now obsolete. Quite honestly I would not recommend anyone, like me, trying to read a 1998 book as a stepping stone from, say 1985 to the current day. I would recommend first reading a textbook like Tanenbaum's 2023 book and then deciding whether it is worthwhile going to Bacon's book. I plan to follow my own recommendation and read Tanenbaum's book in the near future and then come back to this review to put it into perspective. In spite of these comments, I must admit I enjoyed the unusual but logical transdisciplinary flavor of Bacon's book, – I loved the way it linked and integrated key process-related concepts in operating systems, programming languages, database systems, and transaction processing systems in the context of distributed system needs. It is a shining example of a Computer Engineering viewpoint on a very important topic and, in this sense, for me is comparable to Larry Peterson and Bruce Davies's brilliant (and roughly contemporary -1996) Computer Networks: A Systems Approach. For the record, I also believe Bacon's book is a deeper, broader and more reflective look at some of the issues covered by Tanenbaum's 1994 Distributed Operating Systems.
April 15, 2024
Disclaimer: I only gave the textbook a shallow reading and didn’t understand most of it. That said, I think it was a decent introduction to concurrency that has aged surprisingly well I think (I read the 1993 version). Part II was especially good, as the book gives great explanations for semaphores and monitors. Part III was a little confusing because it doesn’t really go into enough detail about deadlocks and how they’re solved in practice. The case studies in Part IV also focused more on general operating systems design than how those systems specifically dealt with concurrency issues. Overall good textbook, solid material for a concurrent systems class if they teach those.
Displaying 1 - 2 of 2 reviews