Product Description
In this second edition, you will find thoroughly updated coverage of the Java(tm) 2 platform and new or expanded coverage of:

* Memory model * Cancellation * Portable parallel programming * Utility classes for concurrency control

The Java platform provides a broad and powerful set of APIs, tools, and technologies. One of its most powerful capabilities is the built-in support for threads. This makes concurrent programming an attractive yet challenging option for programmers using the Java programming language.

This book shows readers how to use the Java platform's threading model more precisely by helping them to understand the patterns and tradeoffs associated with concurrent programming.

You will learn how to initiate, control, and coordinate concurrent activities using the class java.lang.Thread, the keywords synchronized and volatile, and the methods wait, notify, and notifyAll. In addition, you will find detailed coverage of all aspects of concurrent programming, including such topics as confinement and synchronization, deadlocks and conflicts, state-dependent action control, asynchronous message passing and control flow, coordinated interaction, and structuring web-based and computational services.

The book targets intermediate to advanced programmers interested in mastering the complexities of concurrent programming. Taking a design pattern approach, the book offers standard design techniques for creating and implementing components that solve common concurrent programming challenges. The numerous code examples throughout help clarify the subtleties of the concurrent programming concepts discussed.Amazon.com Review
Concurrent Programming in Java, 2nd Edition surveys a wide field of research in parallelism and concurrency and shows how to do more with multithreading in Java with dozens of patterns and design tips. Written for the advanced Java developer, this book offers a comprehensive tour of leading-edge thinking about parallel coding processes.

Within the dozens of techniques and tips offered here, this book accomplishes at least two goals. First, it shows how concurrency is implemented by default within Java, with material on how built-in features (like the synchronized keyword and its memory model) can be expected to perform when dealing with multiple threads. Naturally, Java threads themselves are also covered, including priorities, scheduling, and the like.

Much of this book looks at ways to improve performance of concurrent code beyond the simple default strategies. After defining criteria for measuring concurrent code (such as safety and "liveness," a measure of running live threads effectively), the book presents dozens of techniques for letting threads work together safely. For the working Java programmer, coverage of patterns that have been implemented in the downloadable java.concurrency package will be the most immediately useful. (Within this nearly encyclopedic survey, short code snippets are used for every pattern and concept.)

Though theoretical at times, this book offers plenty of ideas and sample code to get you started thinking of ways to improve multithreaded code.

Impressively comprehensive, Concurrent Programming in Java offers a veritable bible of techniques for doing two things at once with threads in Java. It's a worthwhile guide to the state-of-the-art strategies for improving the performance of your Java threads. --Richard Dragan

Topics covered: Threads and concurrency in Java, design considerations (safety, liveness, and performance), Before/After Patterns, layering, adapters, immutability and synchronization, deadlock, resource ordering, the Java Memory Model and concurrency, using the java.concurrency package, confinement, refactoring for concurrency, mutexes, read-write locks, recovering from failure, notifications, semaphores, latches, exchanges, transactions, one-way messages, worker threads, polling and event-driven I/O, parallelism techniques (fork/join, computation trees, and barriers), Communicating Sequential Processes (CSP). ... Read more

Customer Reviews (48)

Very Good
I don't know about this book but having him as a teacher is pretty weird. I'm assuming his book style is the same as teaching, and that is pretty good, he helps you and knows everything about java seeing how he made some of java. Very bright.

Too Theoretical
The book contains a lot of concurrent and parallel programming theories, but the organization of the contents is not well formed, such that the reading and understanding of the book are hard. The examples giving in the book are not very helpful either.

Overall, the book seems to target for academic researchers rather than developers. Highly recommend "Java Concurrency In Practice" which is much more practical and easier understood by Brian Goetz

5 for knowledge; 0 for the writing -> 2.5-> 2
Sure he knows his stuff but doesn't have a clue on how to write. This is appallingly poorly written. It is one of the most ridiculously disorganized collections of academic 'verbage' (verbiage subsumes garbage) I have ever read. It's almost useless as a reference: its very non-linear (say non-deterministic almost) in concept elucidation (perhaps he's taken the notion of multithreading too much to heart and tried multi-threaded writing???). It's useless as a book to learn from- since learning by example is not just a way to learn, but the only way to learn (Einstein) and this book largely disavows examples.

What it needs is another edition with a ghost writer. Seriously it's not good. Try Paul Hyde for a good intro to threads.

While those at guru-ish level may love this book, those of us for whom threads represent a means to an end, not an end in and of themselves, would probably want to throw this book in frustration of the author's inability to structure a coherent sentence with a clear point. This meanders on like great uncle herb's war stories and is equally will sapping.

Avoid if you can or check it out when you reach guru-ness. It's a good cure for insomnia though.

If you want to program concurency in Java you need this book
This is a kind of book you'll need to start developing concurrent systems in Java. It shows details of what should be done to safely handle patterns for concurrent programs.
I beleive this book is a must for every developer who want to start learning concurrency design priciples for Java.

Great Threaded Programming Information for More than Java
This is the best book I have ever read on threading, and certainly applies well to other languages naturally (especially languages with a modern and mature thread library like Mono/.NET). Unlike other reviewers here, I encourage so-called "beginners" to read this book. He has plenty of examples so you will not get lost, and this *is* the right way to do things, so start with this one. ... Read more

Product Description

“When you begin using multi-threading throughout an application, the importance of clean architecture and design is critical. . . . This places an emphasis on understanding not only the platform’s capabilities but also emerging best practices. Joe does a great job interspersing best practices alongside theory throughout his book.”

– From the Foreword by Craig Mundie, Chief Research and Strategy Officer, Microsoft Corporation

Author Joe Duffy has risen to the challenge of explaining how to write software that takes full advantage of concurrency and hardware parallelism. In Concurrent Programming on Windows, he explains how to design, implement, and maintain large-scale concurrent programs, primarily using C# and C++ for Windows.

Duffy aims to give application, system, and library developers the tools and techniques needed to write efficient, safe code for multicore processors. This is important not only for the kinds of problems where concurrency is inherent and easily exploitable—such as server applications, compute-intensive image manipulation, financial analysis, simulations, and AI algorithms—but also for problems that can be speeded up using parallelism but require more effort—such as math libraries, sort routines, report generation, XML manipulation, and stream processing algorithms.

Concurrent Programming on Windows has four major sections: The first introduces concurrency at a high level, followed by a section that focuses on the fundamental platform features, inner workings, and API details. Next, there is a section that describes common patterns, best practices, algorithms, and data structures that emerge while writing concurrent software. The final section covers many of the common system-wide architectural and process concerns of concurrent programming.

This is the only book you’ll need in order to learn the best practices and common patterns for programming with concurrency on Windows and .NET.

Customer Reviews (13)

5 stars are not enough
Simply put, Joe Duffy is a world-wide authority on this topic. I don't just say that based on working with him (his office was 5 offices down the hall from mine), but also based on the conversations I've seen him dominate with other visionaries inside of Microsoft. If you don't take my word for it, just look at how elegant the Parallel Extensions to the .NET framework are that Joe was the dev lead and architect on. If you want to see examples of how clearly he can put his thoughts to writing, just visit his blog (http://www.bluebytesoftware.com/). 5 stars are not enough for this seminal piece of work.

concurrent programming
good material for beginner and advanced threaded developer. concepts are easy to test compared to other materials on same concept.

Everything about concurrency, and then some
This book provides an exhaustive treatment of everything concurrency in .NET and Win32.



It's organized very clearly into multiple sections: Concepts, Mechanisms, Techniques, Systems, and Appendices, and isn't missing a single thing.From background information about the roots of present day parallel algorithms and architecture, to how Windows and the CLR work internally, to higher level application models and best practices, it's all there...



As other reviewers said, this is the only book you'll need on the topic.The competition just doesn't have the broad coverage and incredible level of depth as this one.The book can be daunting at first, mostly because of its size (almost 1000 pages), but I found it surprisingly well written and enjoyable to read.Much better written than most techie books.It took me a few months to finish.I guess the author could have shortened it, but I don't know what content could have gone; the book just wouldn't be as great without every nugget of information that's in there right now.Some of the sections (like the ones on concurrent containers, detailed parallel algorithms like sorting, and memory models) took multiple reads for everything to sink in.I'm still not sure I've absorbed it all, but thankfully the book's organization makes it suitable as a reference too.



The target audience for the book as stated is any .NET or Windows programmer.Realistically, it's best for senior architects and developers, but could also be used to teach a university course or be read by less experienced developers too.I actually ordered copies for my whole team of 30 developers, all ranging in seniority, and it's basically required reading at this point.The author makes the point that concurrency is everywhere, and it's true. So the book isn't only for advanced new-age parallel programs on multi-core, but also server-side programming (web, app, SQL, map/reduce, data mining) and web apps.Really, everybody needs to know this stuff to be taken seriously.I've started using lots of these topics as interview questions.



What's best, the book is written by a Microsoft guy who runs the team building new concurrency APIs in .NET and Win32 today.(See his blog at http://www.bluebytesoftware.com/blog/ -- there's even a sample chapter there.)This gives the book far more authority than any other on the topic.I've downloaded CTPs of the .NET 4.0 parallel extensions (really amazing stuff), and the book demonstrates in detail how a lot of it is built.There's even an appendix covering the new APIs, so not only does it help build real parallel applications today, it also shows what's coming down the road.



In summary: A fun, enlightening read!I'm actually considering rereading the full 1000 pages again come this summer...

A must for any Windows developer
Multithreading programming is hard and requires a lot of knowledge of the various platforms and a lot of concentration. This book provides a very complete and dense picture of what means multithreading in Windows, elegantly covering both managed and native code. This is definitively a book for programmers, who are eager to not only understand how but also why.

One of the best books on the topic
I'll split my review into 3 parts:

Know what you get (book's goals): 4/10. The book is a bit "all over the place". It's hard to understand the intent of the book -- it's a bit too theoretical for a "pragmatic concurrent development" that it claims to be which makes the entire book a bit fuzzy and way too long. The problem with this kind of books that you usually can't read all (reading 800+ pages is too much for most people) and you're afraid of missing important parts.

Coverage: 9/10. This book is a great "ref" book in my bookshelf, it explains high level architecture to very deep bits&bytes usage in a very readable fashion. I've got a list of pages that I recommended every one of our developers to read, starting from basic things and dive into data structures, interesting pitfalls and solutions and specific tips & tricks that I found very interesting during my reading.

Relevance: 10/10. This is a must have book for windows developers (especially for .Net developers). It contains crucial basics with an amazing list of examples and best practices (need to be pulled out carefully, but it's there).

I'm still missing a well organized "common concurrent pitfalls & solutions" chapter for the pragmatic developers (assuming that the background exists).

All in all, I highly recommend this book! nice work! ... Read more

Product Description

The latest edition of a classic text on concurrency and distributed programming – from a winner of the ACM/SIGCSE Award for Outstanding Contribution to Computer Science Education.

Customer Reviews (7)

still reading it, so far...
i have been reading about concurrency and related issues for quite a while now. after reading a few favorable reviews about this book here and elsewhere, i decided to give it a shot. i have read about 50 pages; what i am going to say will not change as i read more (safety property, if you will).

the part where deadlock and starvation freedom is presented and the example algorithms used for clarification is very dubious and makes me doubt the rigor with which this book was written. granted, deadlock seems to enjoy several slightly different semantics. this should not, however, mean that anything resembling deadlock freedom can be classified under deadlock freedom as its definition. there is one algorithm which clearly is not deadlock-free (under no contention, a thread should be always allowed to enter its critical section) and yet is tagged deadlock-free: its progress depends on the other thread's progress where this other thread might be lost somewhere in its remainder code, showing no interest in the critical section.

now, this example is at the beginning of the book and is about a very simple concept. if the author gets this wrong, what does one think about the rest of the book? will the reader be always on the lookout for possible subtle mistakes? it is my understanding that a reader should be able to trust the writer of the text to fully enjoy the text. this lack of trust made me suspend reading the book. i am trying to get the fundamental notions right before i go any further in this book.

at the end, what does this mean? buy and read this book only if you already have some other reference books on concurrency and want to see yet another approach to a still highly unstable research topic.

Excellent,Amazing Book
This book is only one that I know where you can really study sinchronization method for parallel computing in deep in its mathametic ant strong logic proofs.

Realy AMAZING book

Very Academic
This book did provide a good method of creating tables to help identify concurrency issues and as a possible method for analysis of concurrent systems.However, the presentation within this book is extremely dry and this newly learned method is truly overkill for most applications.If one wants to learn about the academic perspective on concurrent programming, then this book is absolutely for you, but if you want a book to give you the concepts and then some practical applications within Windows or Linux then you should definitely look elsewhere.

An excellent rigorous introduction
An excellent, rigorous, mathematical introduction to concurrent programming.This book concentrates on principles and theory, providing an excellent background for concurrent programming.

Readers expecting a tutorial on pthreads or win32 threads should look elsewhere.

A calculus for reasoning about concurrent programming is presented, along with problems, solutions, and proofs for common concurrent programming concerns.

A superb academic treatment of the topic, but not for the weak kneed.

Very good introduction
Used at the University of Liege, Belgium as reference for the Parallel System lecture. Everyone found it very useful ... Read more

Product Description
Concurrent Programming shows readers how to utilize the Java programming language to write programs that use semaphores, monitors, message passing, remote procedure calls, and the rendezvous for thread synchronization and communication. A Java algorithm animation package is also described. ... Read more

Customer Reviews (4)

Horrible
Let's get something straight, I'm currently a college student at Drexel University (The Author's college).I am a Dual BS/MS Student with a GPA > 3.8 in computer science.This book is without a doubt the worst book I've ever been forced to purchase for a class and I am fully convinced that we only use it because the author is part of the community at this school.As has been mentioned before, the code samples are not labeled.Working with the code is also a horrendous experience trying to figure out which problem matches up with which set of 4 letter source files (such descriptive names as "bbpc.java").I do not agree that the theory is all that great in this book.Personally, I think that by reading the Javasoft tutorial one can get a better understanding of Concurrent Programming.The other reviewers are also correct in saying that the book is very poorly edited.It looks like something banged out over a month's period or time.My Recommendation?Don't buy this book, and if your professor makes you buy it for a class, protest.I told mine flat out that the book (...).Not much came of it, but at least it's out in the open.I would give this book a negative rating if (possible).

Poorly Edited. Oxford UP should be ashamed.
This book is passably written by an author who cares much more about concurrent applications than about java.Java is perhaps just a hook to get you to buy the book.Why spend chapters on semaphores when thelanguage has native monitor support? The editing of this book, however,makes it nearly unreadable and unusable.The text regularly refers to"Class 2.5" or "Listing 3.4" (for example) yet none ofthe code listings are labeled, and may not be on the same page.You'lldrive yourself nuts trying to figure out what he's talking about.Also,the text makes reference to code and listings that can only be found on theauthor's web page without explicitly stating this.Finally, is the firstphilosopher "Philosopher 1" or "Philosopher 0"?Aneditor should have picked this up and corrected it.

Not bad, but not enough for programming
I was assigned to use this book as text book, I find it is a good book buta little different in real programming. The theory is much more easy thanother books.

Ho-Hum
The book is great on theory and poor on programming ideas.He writes "The best way to debug a Java program is with the System.out.println statement, as is the case with any high-level programming language." Inexcusable language for a professor in computer science. ... Read more

Product Description

The first textbook that focuses purely on Synchronization - a fundamental challenge in Computer Science that is fast becoming a major performance and design issue for concurrent programming on modern architectures, and for the design of distributed systems.

Customer Reviews (2)

One of the best books on the item
The book gives an excellent description for advanced topics in synchronization problems( at least this topics are advanced for an ordinary engineer who has hardly encountered something beside read-write spin locks and semaphores ). In my opinion one of the most interesting chapters are those that include theorems which give a low space boundary posed by the properties of objects used for synchronization.
The book is on the same level as Herlihy and Shavit's "The art of multiprocessor programming". I would recommend to read the both - it is hard to choose the better one, they both are excellent.

Excellentbook for concurrent programming
The book introduces the fundamental concepts of concurrent programming and presents synchronization methods and techniques used for solving numerous problems in programming multiprocessor (multicore) computer architectures. It is written in a clear style that makes it a pleasure read. A superb academic treatment of the topic.
... Read more

Product Description
This book is designed as a first book on concurrent programming and provides a comprehensive introduction to the problems of concurrency. The book builds on the reader's familiarity with sequential programming in a high-level language. It is concerned mainly with the high-level aspects of concurrency, which will be equally applicable to traditional time-sliced or more recent truly parallel systems. Topics covered include: processes and inter-process communication, shared data and message passing constructs, languages for concurrency, and the implementation of concurrent kernel. ... Read more

Product Description
This collection of original research provides a comprehensive survey of developments at the leading edge of concurrent object-oriented programming. It documents progress - from general concepts to specific descriptions - in programming language design, semantic tools, systems, architectures, and applications. Chapters are written at a tutorial level and are accessible to a wide audience, including researchers, programmers, and technical managers.The problem of designing systems for concurrent programming has become an increasingly important area of research in computer science with a concomitant increase in the popularity of object-based programming. Because parallelism is a natural consequence of the use of objects, the development of systems for concurrent object-oriented programming is providing important software support for a new generation of concurrent computers.Gul Agha is Assistant Professor in the Department of Computer Science at the University of Illinois at Urbana-Champaign. Peter Wegner is Professor in the Department of Computer Science at Brown University. Akinori Yonezawa is Professor at Tokyo Institute of Technology. ... Read more

Product Description
Expert guidance for those programming today’s dual-core processors PCs

As PC processors explode from one or two to now eight processors, there is an urgent need for programmers to master concurrent programming. This book dives deep into the latest technologies available to programmers for creating professional parallel applications using C#, .NET 4, and Visual Studio 2010. The book covers task-based programming, coordination data structures, PLINQ, thread pools, asynchronous programming model, and more. It also teaches other parallel programming techniques, such as SIMD and vectorization.

• Teaches programmers professional-level, task-based, parallel programming with C#, .NET 4, and Visual Studio 2010
• Covers concurrent collections, coordinated data structures, PLINQ, thread pools, asynchronous programming model, Visual Studio 2010 debugging, and parallel testing and tuning
• Explores vectorization, SIMD instructions, and additional parallel libraries

Master the tools and technology you need to develop thread-safe concurrent applications for multi-core systems, with Professional Parallel Programming with C#. ... Read more

Product Description
Real-time functionality is essential for developing many consumer, industrial, and systems devices. While the C/C++ programming language is most often used in the creation of real-time software, the Java language, with its simple and familiar object-oriented programming model, offers many advantages over current real-time practices. Concurrent and Real-Time Programming in Java covers the motivations for, and semantics of, the extensions and modifications to the Java programming environment that enable the Java platform (Virtual Machine) to meet the requirements and constraints of real-time development. Key aspects of concurrent and real-time programming and how they are implemented in Java are discussed, such as concurrency, memory management, real-time scheduling, and real-time resource sharing. ... Read more

Customer Reviews (1)

Finally, somebody makes sense of threads
The basic syntax of C++ gave us all more than enough rope to hang ourselves. Java took that rope away when Gosling removed templates, operating overloading, and added garbage collection. But then he backed up the rope truck and unloaded threads on us. Now I see far too many programmers jumping into the world of Heisenbugs by building threaded applications without the proper understanding of their best use.

That's where this book comes in. It starts with the threading basics, but then goes on to show best practice strategies for the use of threads and architectures to manage threads. And what's more, the author gives us case studies that detail how these strategies and architectures are implemented.

There was a desperate need for this book, and the author has filled the void with excellent material. I strongly recommend this book to any Java programmer using threading. Which is to say, almost everyone. ... Read more

Product Description
Presents state of the art results on Petri Nets and concurrent object-oriented programming in a coherent and competent way. Softcover. ... Read more

Product Description
Concurrent Programming ML (CML), included as part of the SML of New Jersey (SML/NJ) distribution, combines the best features of concurrent programming and functional programming. This practical, "how-to" book focuses on the use of concurrency to implement naturally concurrent applications. In addition to a tutorial introduction to programming in CML, the book presents three extended examples using CML for practical systems programming: a parallel software build system, a simple concurrent window manager, and an implementation of distributed tuple spaces. This book also illustrates advanced SML programming techniques, and includes a chapter on the implementation of concurrency using features provided by the SML/NJ system. It will be of interest to programmers, students, and professional researchers working in computer language development. ... Read more

Customer Reviews (2)

Very nice book
This book is really good. Everything is absolutely clear, and decisions related to the design of CML itself are explained, as well as how to use the language. Besides, Chapter 2 has the best short (<40 pages) introduction to basic concepts in concurrent programming that I have seen.

Buy this book!
This is a book on Concurrent ML by the man who invented it.With so little CML information available on the web, this book has been one of the best investments I've made in years.Reppy starts off with a review of concurrency theory and then illustrates programming in CML through big, real-world examples.Throughout the book, he explains the motivation behind his design decisions.You end up with a clear picture of concurrent programming in a functional language -- concurrent programming in a REAL language like ML ... ... Read more

Product Description
JR is a language for concurrent programming. It is an imperative language that provides explicit mechanisms for concurrency, communication, and synchronization. JR is an extension of the Java programming language with additional concurrency mechanisms based on those in the SR (Synchronizing Resources) programming language. It is suitable for writing programs for both shared- and distributed-memory applications and machines. The JR implementation executes on UNIX-based systems (Linux, Mac OS X, and Solaris) and Windows-based systems. It is available free from the JR webpage.The JR Programming Language: Concurrent Programming in an Extended Java, an advanced-level text book, describes the JR programming language and illustrates how it can be used to write concurrent programs for a variety of applications. This text presents numerous small and large example programs. The source code for all programming examples and the given parts of all programming exercises are available on the JR webpage. Dr. Ronald A. Olsson and Dr. Aaron W. Keen, the authors of this text, are the designers and implementors of JR.The JR Programming Language: Concurrent Programming in an Extended Java is designed for upper-level undergraduate and graduate-level students in computer science. This book is also suitable for a professional audience, composed of researchers and practitioners in industry. ... Read more

Product Description
Ada is the only ISO-standard, object-oriented, concurrent, real-time programming language. It is intended for use in large, long-lived applications where reliability and efficiency are essential, particularly real-time and embedded systems. In this book, Alan Burns and Andy Wellings give a thorough, self-contained account of how the Ada tasking model can be used to construct a wide range of concurrent and real-time systems. This is the only book that focuses on an in-depth discussion of the Ada tasking model. Following on from the authors' earlier title Concurrency in Ada, this book brings the discussion up to date to include the new Ada 2005 language and the recent advances in real-time programming techniques. It will be of value to software professionals and advanced students of programming alike: indeed every Ada programmer will find it essential reading and a primary reference work that will sit alongside the language reference manual. ... Read more

Customer Reviews (5)

The "gold standard" for Ada 2005 in concurrent and real-time apps
Fully harnessing multi-core processors requires concurrent programming, yet most mainstream languages have little support or do so with poor portability.Well-written concurrent Ada programs can be extremely portable and support multi-core and multiple processors automatically.This book explores, in-depth, the concurrent programming ("tasking") part of the Ada language.The authors then show how the concurrent programming facilities of Ada are augmented by the language to support real-time programming.These standard real-time facilities are state-of-the-art, extending, for example, beyond the POSIX real-time facilities in their expressive power.

The book first establishes the necessary foundation for understanding concurrent programming by explaining the possible problems (e.g., deadlocks and race conditions) and highlighting some of the mechanisms traditionally used in concurrent programming, such as semaphores and message-passing.

The tasking part of Ada is then covered in full detail, necessarily including interactions with some other parts of the language, such as exceptions, but also including interactions with the Ada object-oriented language facilities.The implementations of a number of reusable concurrency abstractions serve to illustrate the use of the tasking features.

The authors next lay another foundation, this time for scheduling in real-time systems, and show how Ada directly supports the common approaches.Both fixed-priority and dynamic-priority dispatching are supported by Ada and these are covered in detail.Ada 2005 also defines a number of time-related abstractions, such as a monotonic clock and timing events, and these are also covered completely.As in the concurrent programming part of the book, a number of reusable abstractions are implemented; in this section they illustrate the real-time language facilities.A discussion of the popular Ravenscar Profile, adopted by some other languages, is included.

No language is perfect and Ada is no exception.The tasking part of Ada 83 was particularly controversial in the domain of real-time systems.Ada 95 addressed many of these issues and added some new ones.Ada 2005 does the same.These issues are not ignored in the book.

I own 46 books on Ada (not counting older editions of some of them), gathered over 27 years of applying the language.Some are excellent and some not, but this one is highly prized.I highly recommend it to professionals and students alike.

Good for any programmer
Obviously specifically for Ada but a good resource for any programmer interested in the general concept of concurrent programming.The organization of the chapters and the introduction to concurrency are alone worth the price.

very informative contents about ada task acts
the authors of this book is famous. and the contents of the book do not disappoint me.

i have several references about ada. of course, some of the references are written by the author of this book. But, regard to the acting mechanism of ada task, this book is awesome.

but, if you are the beginner of real-time & embedded system, you should have another reference(s) to fully understand the meaning of the every article of this book.

The definitive work on concurrency in Ada
By far the best on the subject.Offers complete coverage of any aspect of concurrency with Ada, including real-time and distributed programming issues.Burns and Wellings are the acknowledged experts on thistopic.

The best aspect of the book is the analysis of features and theirinteractions, providing a depth not available in other texts covering theentire language.

Assumes you know some Ada, but includes an introductionto the sequential part of the language.

I own quite a few books on Ada;this is the one to get if you want the details of Ada concurrency.

ESSENTIAL & EXCELLENT for every PROFESSIONAL PROGRAMMER
Ada has been one of few languages which provides facilities for concurrent programming, but readings for the feature had been limited. This book is not only the first but also an excellent guide to the capability of the new Ada standard.

It covers,

1.@The Ada Language

2. The Nature and Uses of Concurrent Programming

3. Inter-Process Communication

4. Ada Task Types and Objects

5. The Rendezvous

6. The Select Statement and the Rendezvous

7. Protected Objects and Data-Oriented Communication

8. Avoidance Synchronisation and the Requeue Facility

9. Using Protected Objects as Building Blocks

10. Exceptions, Abort and Asyncronous Transfer of Control

11. Tasking and System Programming

12. Real-Time Programming

13. Object-Oriented Programming and Tasking

14. Distributed Systems

15. Conclusion

Not only Ada programmers, but also all professonal software engineers who design real-time, embedded systems, advanced students of computer science, and even beginners should find it quite useful.

I've read the original print published in 1995, which has been out-of-print.

I am so happy to know it is now to be RE-PRINTed, and every programmers would be. ... Read more

Product Description

Customer Reviews (37)

Not bad
Very good introduction to Erlang, covers all the important basics. Written in an easy to follow way, with mostly interesting examples and some exercises for the reader.

good topic, terrible writer :(
I bought it as one of my course books. The language itself has some pretty cool things that makes distributed programming easy. The book, however, is quite poorly written. If I had to buy an erlang book again (and its not a mandatory course book), I wouldnt buy it again. Look online for better help with Erlang.

A good introduction to Erlang
I am currently in the process of learning Erlang for a personal project. These books both measures up to the high expectations I have come to expect from Pragmatic Programmers Publishing.

Erlang is a difficult language to "sell", and is a challenge to learn.

This book assumes you have decently good programming skills, and don't need your hand held too much about the idea of programming, and instead show you how Erlang is different, it's unique and interesting features, and some of "how to think in Erlang".

I wish there was more on "how to think in Erlang", especially since most programmer's intuitions about multiprocessing and concurrency, born of battle scars with multithreaded programming in C/C++, will be wrong.

not a good book writer
yes, the author invented the language and there is few choice of erlang books.

but I do not believe Joe is a good book writer, it does not cover anything deep enough as I could expect. As an introduction level book, it is not well organized at all.

Most of The Pragmatic Bookshelf books are outstanding, this is an exception.

Good enough
As of 2009 there are not many alternatives to learn the powerful programming language Erlang and the OTP (Open Telecom Platform). This is THEbook written by the designer and implementor of Erlang, Joe Armstrong and he seems to know what he is talking about. High quality humour may not be one of Armstrong's strengths but when it comes to finding attractive examples he shines using his favorite language and platform.

This may not be the perfect book, it has its problems such as promising that some things will be pointed out but the chapter ends without fulfilling it. A few minor frustrations aside the book provides a very good overview of the most important points of Erlang with enough breadth and depth. The chapter where Armstrong talks about a simple then adding transaction semantics, fault tolerance, hot code swapping, etc. is a kind of tour de force. Another good application is a Shoutcast server implementation in just a few lines of code. It would be very good to compare this example to Peter Seibel's Practical Common Lisp [1].

If you want to learn more about this kind of programming, I'd definitely suggest reading 'Concepts, Techniques, and Models of Computer Programming' [2] which shows the Oz programming language and the Mozart platform and teaches the fundamentals of message-passing concurrency and network-transparent distributed programming.

Finally it must be repeated that Erlang has a very high-quality VM along with mature libraries for concurrency and reliability. If you want to experience industrial-strength distributed and / or multicore applications that scales well then it would be only wise to follow the advice of Joe Armstrong.

Warning: If you are not exposed to Lisp, Prolog, Haskell, Oz, etc. beforehand be careful for a different kind of syntax and semantics. You'll have unlearn a few concepts to understand the power of new concepts.


[...] ... Read more

Product Description
This book provides an in-depth overview of underlying principles as well as practical techniques that can be used to design concurrent programs. Anyone interested in sequential and concurrent computing will find this book to be an essential reference and innovative work. Andrews's shows how to approach key decisions, discusses the tradeoffs between how processes should be used, and explains how those processes should interact. ... Read more

Customer Reviews (1)

It's a bit heavy stuff but well organized text book
It is a good book for anyone who wants to lecture in concurrent programming.This book will also help anyone explain the confusion among concurrent, parallel and distributed programs which have been around for the last three decades. The author touches the same three underlyingconcepts : processes, communication and synchronization.The ten chaptersof the book is organized into four parts : basic concepts, sharedvariables, message passing and pratice. The first part, basic concepts,provides a formal presentation to introduce an assertional proof techniquesfor sequential and concurrent programming. The second and third parts,shared variables and message passing, elaborates the two major categoriesof synchronization technique in concurrent programming. Systematic methodto solve synchronization problems are described throughout the chapters intwo. In the last part, practice, the author provides an overview of fiveconcurrent languanges : Turing Plus, Occam, Ada, SR and Linda. Comparisonand performance experiments of all languanges are also provided in the lastchapter. The book also includes some classic concurrent programmingproblems such as critical sections, producers and consumers, readers andwriters, the dining philosophers and resource allocation. The 'HistoricalNotes and References' provided at the end of every chapter is a plus inwhich it provides citations to relevant literature and more insights to therelated subject. ... Read more

Product Description
Erlang is a programming language for building robust concurrent systems. The language is the result of research into the combination of modern ideas about declarative programming with conventional process based models of computation for real-time applications. The language is being widely used in the telecommunications industry and has been used both for prototyping and product development. Erland integrates ideas from logic and functional programming with a process/message passing model of concurrency to provide a solid basis for the development of embedded real-time robust distributed software. Erlang programs are typically five times shorter than their equivalents in conventional languages, so project development times can be greatly reduced. This book is a complete description of Erlang and contains many examples of how robust real-time systems can be programmed using Erlang. ... Read more

Customer Reviews (2)

Could use more rigor, but recommended
This book explains the Erlang language and distributed programming system, which is now an open source system. It has the benefit of simplicity plus expressiveness. A good antidote to the current Java rage. The book isinformal, which makes it a good tutorial, but I wish it also had a moreformal supplement.

good book with real-life examples
In general, this book was well worth the money paid.It's reasonably comprehensive and written for people who actually plan on writing Erlang programs.Furthermore, it even uses understandable real-life examples. ... Read more

Product Description
Concurrent computing is gaining ground in interest as it becomes increasingly feasible to implement distributed computing across networks of workstations. This book, by one of the subject's leading figures, provides a comprehensive survey of the subject beginning with proposotional logic and concluding with concurrent programming. It is based on graduate courses taught at Cornell University and is designed to be used as a graduate text. There are exercises at the end of each chapter to extend and illustrate the main themes covered. Professor Schneier emphasizes the use of formal methods and assertional reasoning using notation and paradigms drawn from programming to drive the exposition. As a result, all those interested in studying concurrent computing will find this to be an invaluable approach to the subject. ... Read more

Customer Reviews (1)

Concurrent programming is very risky!
< One of the most insidious sources of programming problems in the RISKS archives involves concurrent programming.Synchronization, locking, message passing, and other tight-coupling mechanisms are extremely difficult to do properly.Programming languages and operating systems are not necessarily much help by themselves.

Fred Schneider has put together a wonderful book on how to do concurrent programming correctly.Whereas the book is ideal for a one-semester course (and more), it is also very valuable as a reference work.It should be read by everyone deeply involved in writing critical programs.Although its focus is strongly on formal methods, I have long claimed that formal methods can be enormously helpful if you are really concerned about correctness in concurrency, for which most unproved algorithms tend to have flaws (and a few ``proved'' ones may also).Furthermore, the implementations of such algorithms are always in question, and formal methods can help significantly there as well.

[From the Risks Forum, vol 19 no 51]

... Read more

Product Description

Coloured Petri Nets (CPN) is a graphical language for modelling and validating concurrent and distributed systems, and other systems in which concurrency plays a major role. The development of such systems is particularly challenging because of inherent intricacies like possible nondeterminism and the immense number of possible execution sequences.

In this textbook Jensen and Kristensen introduce the constructs of the CPN modelling language and present the related analysis methods in detail. They also provide a comprehensive road map for the practical use of CPN by showcasing selected industrial case studies that illustrate the practical use of CPN modelling and validation for design, specification, simulation, verification and implementation in various application domains.

Their presentation primarily aims at readers interested in the practical use of CPN. Thus all concepts and constructs are first informally introduced through examples and then followed by formal definitions (which may be skipped). The book is ideally suitable for a one-semester course at an advanced undergraduate or graduate level, and through its strong application examples can also serve for self-study. An accompanying website offers additional material such as slides, exercises and project proposals.

Book website: http://www.cs.au.dk/CPnets/cpnbook/

Customer Reviews (1)

Is this a breakthrough, undersold?
I'm not a compsci grad, but it seems to me if Gehani and Roome packaged their book with a CD-ROM of the compiler, they would have a revolution on their hands!

Being a Lucent employee I got a tar file of the compiler. It only runs on UNIX boxes and with C++ 2.1. But even with these limitations (and those imposed by having to debug via #ifdef DEBUG directives) this stuff is gold.

Any other readers care to comment? ... Read more