Programming Concurrency on the JVM and over 2 million other books are available for Amazon Kindle . Learn more
FREE Delivery in the UK.
Only 2 left in stock (more on the way).
Dispatched from and sold by Amazon.
Gift-wrap available.
Quantity:1
Programming Concurrency o... has been added to your Basket
Used: Like New | Details
Sold by Super Media
Condition: Used: Like New
Comment: Fast delivery from Amazon! Qualifies for Prime Delivery and FREE standard delivery. Overnight, 2 day and International delivery available! Excellent Customer Service.. May not include supplements such as CD, access code or DVD.
Trade in your item
Get a £3.33
Gift Card.
Have one to sell?
Flip to back Flip to front
Listen Playing... Paused   You're listening to a sample of the Audible audio edition.
Learn more
See this image

Programming Concurrency on the JVM: Mastering Synchronization, STM, and Actors Paperback – 5 Sep 2011


See all 2 formats and editions Hide other formats and editions
Amazon Price New from Used from
Kindle Edition
"Please retry"
Paperback
"Please retry"
£22.50
£11.58 £11.25
£22.50 FREE Delivery in the UK. Only 2 left in stock (more on the way). Dispatched from and sold by Amazon. Gift-wrap available.

Frequently Bought Together

Programming Concurrency on the JVM: Mastering Synchronization, STM, and Actors + The Well-Grounded Java Developer: Vital techniques of Java 7 and polyglot programming + Java Performance (Java (Addison-Wesley))
Price For All Three: £79.19

Buy the selected items together



Trade In this Item for up to £3.33
Trade in Programming Concurrency on the JVM: Mastering Synchronization, STM, and Actors for an Amazon Gift Card of up to £3.33, which you can then spend on millions of items across the site. Trade-in values may vary (terms apply). Learn more

Product details

  • Paperback: 280 pages
  • Publisher: Pragmatic Bookshelf; 1 edition (5 Sep 2011)
  • Language: English
  • ISBN-10: 193435676X
  • ISBN-13: 978-1934356760
  • Product Dimensions: 19 x 2.7 x 22.9 cm
  • Average Customer Review: 5.0 out of 5 stars  See all reviews (3 customer reviews)
  • Amazon Bestsellers Rank: 217,742 in Books (See Top 100 in Books)

More About the Author

Discover books, learn about writers, and more.

Product Description

Review

""There has been an explosion of interest and application for both new concurrency models and new languages on the JVM. Venkat's book ties it all together and shows the working developer how to structure their application and get the most out of existing libraries, even if they were built in a different language. This book is the natural successor to Java Concurrency in Practice.""--Alex Miller, Architect/Senior Engineer, Revelytix, Inc.""If the JVM is your platform of choice, then this book is an absolute must-read. Buy it, read it, and then buy a copy for all your team members. You will well be on your way to finding a good solution to concurrency issues.""--Raju Gandhi, Senior consultant, Integrallis Software, LLC""An excellent book! Venkat skillfully leads us through the many design and implementation decisions that today's JVM developer faces in multithreaded programming. His easy-to-read style and the many examples he provides--using a variety of current open source tools and JVM languages--make this complex topic very approachable.""--Albert Scherer, Manager, eCommerce Technologies, Follett Higher Education Group, Inc.

About the Author

Dr. Venkat Subramaniam is an award-winning author, founder of Agile Developer, Inc., and an adjunct faculty at the University of Houston. He has trained and mentored thousands of software developers in the US, Canada, Europe, and Asia, and is a regularly-invited speaker at several international conferences.


Inside This Book (Learn More)
Browse Sample Pages
Front Cover | Copyright | Table of Contents | Excerpt | Index
Search inside this book:

What Other Items Do Customers Buy After Viewing This Item?

Customer Reviews

5.0 out of 5 stars
5 star
3
4 star
0
3 star
0
2 star
0
1 star
0
See all 3 customer reviews
Share your thoughts with other customers

Most Helpful Customer Reviews

Format: Paperback
The review is for the Beta version of "Programming Concurrency on the JVM: Mastering Synchronization, STM, and Actors" as of March 23, 2011 which I generously received from the publisher.

The book "Programming Concurrency on the JVM: Mastering Synchronization, STM, and Actors" focuses on three concurrency models - java.util.concurrent API, STM and actor-based concurrency model - to handle (or rather avoid) troubles with shared mutable, isolated mutable and purely immutable state. As the author points out in the Preface (page 10) "In this book, we'll take an example-driven approach to learn the three models" and he sticks to it. The example-driven approach is mostly based upon Java and Scala with two dedicated chapters for the other JVM languages - Clojure, Groovy and JRuby. You'll find enough to get up to speed with Akka/Multiverse and very few words about GPars.

The author makes it crystal clear that he's "written this book for experienced Java programmers who are interested in learning how to manage and make use of concurrency on the JVM, using languages like Java, Clojure, Groovy, JRuby and Scala" (page 10). You won't find an explanation between multithreaded and concurrent application. You won't find the book very in-depth into concurrency either. The book's, however, sufficient to let you be aware of concurrency issues and how to tackle or, better, avoid them.

While I was reading the Preface I set out the reading plan for the book that assumed to have started off with the chapters 1-3 and have jumped right into Clojure's STM (the chapters 6-7) which I was the most interested in. The whole plan felt down right after the chapter 2 when I found out I'd been better off following along the book order. It paid off very well.
Read more ›
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
Format: Paperback Verified Purchase
I recommend this book.
All the toppics are exposed very clear and concise. The chapter about actors is really good
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
Format: Paperback
Are you a Java programmer? Buy this book.
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again

Most Helpful Customer Reviews on Amazon.com (beta)

Amazon.com: 12 reviews
18 of 19 people found the following review helpful
An important work on a challenging topic 31 Aug 2011
By Brian Tarbox - Published on Amazon.com
Format: Paperback
This book should be considered part of a two book series along with Venkat's 2009 book "Programming Scala: Tackle Multi-core Complexity on the JVM". The earlier book was a relatively short (250 pages versus 852 pages for Oderski's Scala book), perhaps too short, overview of Scala. It's 12 chapters skip over lots of the details in Oderski's 18 chapter book, and contains only a single chapter on Concurrent Programming.

By comparison the new book is all about Concurrent Programming models and attempts to be agnostic about the JVM language to be used. Most examples are first given in Java, then a simpler way is shown to do it in Scala, and then often a short section saying how the example could be done in Ruby.

The book describes the difficulties of concurrent programming in JVM languages especially given the rise of multi-core processors. It then describes three "solutions": the naïve Java approach, Software Transactional Memory and Actors. It should be noted that the Actors chapter is based on Akka, so if you don't care for Akka you may not like this book.

The Power and Perils of Concurrency - This should be an unsurprising recap of well known problems; if you're reading this book you will almost certainly have run into the problems listed here already.
Strategies for Concurrency - Talks about ways to divide problems into parts that can be computed independently

Modern Java/JDK Concurrency - This talks in detail about the changes made to the Java libraries to better support concurrency, specifically things like using ExecutorService rather than "new Thread()" and using Lock vs. synchronized. Interestingly though the chapter fails to discuss the little known but serious differences between synchronized blocks and methods involving fairness and barging.

Taming Shared Mutability - This chapter begins to offer the Scala kool-aid of mutability is bad. Reading this chapter is made easier if you've already read Goetz's "Programming Concurrency".

Software Transactional Memory - This chapter talks about Clojure's STM model and how to use it in Java via Akka. Its an interesting chapter but one that will feel odd if you're a programmer also coming to terms with non-relational databases. As databases move away from the transitional transactional model here comes STM bringing transactions to mutable variables.

Actor-based Concurrency - Actors are basically a message passing schema where immutable messages are passed between lightweight actors (thread-like). Just as you can use thread pools to reduce the cost of threads there are what amount to actor pools which lighten their cost. It does require some rethinking to embrace the actor approach.

Overall this is a fine book that brings quite a lot to the table. My only reservation would be that if you are a seasoned Java programmer you might take the first four sections as a given and jump right to the Actors approach. And if you're not a seasoned Java programmer you probably don't realize how badly you need this book.
16 of 20 people found the following review helpful
Skimpy 25 Oct 2011
By Steven Barnes - Published on Amazon.com
Format: Paperback Verified Purchase
I am a veteran Java programmer, looking to move into Scala, using Akka actors. As "Actors in Scala" wasn't released yet, this looked like the best choice. Unfotunately, the "language neutral" aspect of the book will probably satisfy no one. Too much space is used to repeat the same concepts, but in different languages. Particularly annoying was a section on actors, in which a problem is first implemented in Java, then Scala; then we are shown the use of Typed Actors (which are conceptually very similar to untyped actors) to implement the same problem, again in both Java and Scala (making that 4 detailed implementations and explanations of the same problem, instead of highlights of the important differences). This like a freshman padding out his term paper.

I was hoping for a book that would go into deep concepts related to actors and STM. This is more of an introduction to modern JVM concurrency idioms, with a few variations on the usual highly simplified programming examples one can find on web blogs, such as the obligatory bank account implementation.

Still, there were some interesting bits of theoretical background which I did not know, such as the formula for determining the number of threads to use in an application based on how compute-bound the tasks are.
2 of 2 people found the following review helpful
JVM programming is not only about the threads and synchronization - say hi to STM and Actors! 26 Feb 2013
By vrto - Published on Amazon.com
Format: Paperback
Concurrency programming is hard. Concurrency programming in Java is even harder. There are some wonderful books that address concurrency programming in Java like "Java Concurrency in Practice (JCIP)" from B. Goetz, D. Lea and others.

This book will introduce concurrent JVM programming and it consists of three big parts. The first one targets specifically Java's concurrent utilities (synchronization, executing threads, java.util.concurrent package, Fork-Join API and so on). Author does rather good job explaining things from the scratch here, but if you've read JCIP you probably won't find many new things.

The second part describes Software Transactional Memory (STM) model and tries to describe how can concurrent programming be easier when we try to separate state and identity of the object. Cool thing is that examples are not only in Java, but you can find some more expressive ways how to use STM with Scala, Clojure, Groovy or JRuby.

The last important part is about the Actor model. You will learn something about isolated mutability and will understand how much easier is to achieve this with actors. Personally, this was the most interesting part of the book for me. Author is mostly using thepopular Akka framework and examples are again in multiple languages that I've mentioned in previous paragraph.

Before you decide to buy and read this book - bear in mind that it's not going to be easy. In fact, it's going to be pretty hard. This is really is not that kind of relaxing book for long evenings, it's rather hardcore challenge. It's only up to you if you're willing to accept it.
4 of 5 people found the following review helpful
Example-driven approach to concurrency on the JVM (with Java, Scala, Clojure, Groovy and JRuby) 1 Mar 2012
By Jacek Laskowski - Published on Amazon.com
Format: Paperback
The review is for the Beta version of "Programming Concurrency on the JVM: Mastering Synchronization, STM, and Actors" as of March 23, 2011 which I generously received from the publisher.

The book "Programming Concurrency on the JVM: Mastering Synchronization, STM, and Actors" focuses on three concurrency models - java.util.concurrent API, STM and actor-based concurrency model - to handle (or rather avoid) troubles with shared mutable, isolated mutable and purely immutable state. As the author points out in the Preface (page 10) "In this book, we'll take an example-driven approach to learn the three models" and he sticks to it. The example-driven approach is mostly based upon Java and Scala with two dedicated chapters for the other JVM languages - Clojure, Groovy and JRuby. You'll find enough to get up to speed with Akka/Multiverse and very few words about GPars.

The author makes it crystal clear that he's "written this book for experienced Java programmers who are interested in learning how to manage and make use of concurrency on the JVM, using languages like Java, Clojure, Groovy, JRuby and Scala" (page 10). You won't find an explanation between multithreaded and concurrent application. You won't find the book very in-depth into concurrency either. The book's, however, sufficient to let you be aware of concurrency issues and how to tackle or, better, avoid them.

While I was reading the Preface I set out the reading plan for the book that assumed to have started off with the chapters 1-3 and have jumped right into Clojure's STM (the chapters 6-7) which I was the most interested in. The whole plan felt down right after the chapter 2 when I found out I'd been better off following along the book order. It paid off very well. The vivid, lively and often humorous writing style invites for further reading and has an extraordinary hypnotic quality. Chances are a chapter or two will not suffice for a single uninterrupted reading session. Many complete yet succinct examples don't let you get bored, and the languages as well as the intensive introduction to Akka set my mind racing all the time. The book flattens the learning curve of concurrency on the JVM substantially.

No idiomatic code, no introduction to any of the languages, no unnecessary import statements in the code listings, just a bare minimum for a topic at hand. The book's very informative, succinct and concise. Recommendations for effective concurrent applications are everywhere. The book's fully packed with them. The figures, the surprisingly large number of examples are all in the book to lend a helping hand. If that'd not been enough, the book provides eye-opening examples from real life and book references. Learning by examples is constantly utilized. Very handy examples; no clutter, just code that's necessary to get the point across. People who're not accustomed with Clojure, Scala, Groovy or JRuby may find the examples a bit uneasy and suffer a great pain wondering if nothing's missed. There're some language terms that are not explained yet extensively used or referred to (to me Scala's trait was the most mysterious term which I had a vague understanding of).

The respective language chapters - the chapters 7 and 9 - follow the same scheme to explain a topic, so reading their sections one by one will quickly reveal the similarity and may turn out a bit boring or even annoying. The author did make it clear in the opening section when he wrote "Focus on the sections related to the languages you're interested in, and feel free to skip the others." (page 152).

You can gain proficiency in Java concurrency quickly, perhaps too quickly for some. People who need elaborative, almost academic treatment of the topic will not find much in here. If your goal's to hone in on concurrency with code samples, the book will make it quick and easy. Be careful, though, as the examples are often quite intensive on using a language and anonymous, inner classes, generics and traits are the norm.

As a side-effect, I learnt that "Groovy is not thrilled to see" package objects in Scala, learnt about JRuby's wrapping exceptions into NativeException or importing Scala's package classes woes in Java. I'm encouraged to give Scala a serious try, too.

The book gradually develop a reasonable level of competence in concurrency on the JVM. It's so vigilant to ensure necessary details are all in one place easily found and comprehensible. Sufficiently in-depth to build a confidence in designing highly concurrent applications or tackling concurrency issues.

It's not uncommon to find one or two ending sections as a sort of summary for the entire chapter. The Recap's are often too short and with the previous summary-like sections seems unnecessary, but quite a few can also be used as a single-page, one-stop reference to be printed out and hang on the wall.

I enjoyed a great deal of excellent technical writing. The book brought more knowledge than I could digest upon a single reading. It's very language-rich and therefore mind-twisting's incurred. Rest assured you'll find plenty of useful information to introduce in your code right away.

Opt to read the book and it will reward you with a couple of ready-to-apply advices to set out a smooth sail to the world of concurrency on the JVM. To put it simply, I love it and will surely get back to it often.
1 of 1 people found the following review helpful
Good pedagogy 13 Feb 2013
By Rick Goff - Published on Amazon.com
Format: Paperback Verified Purchase
This book is remarkably well written - as a teaching book. Subramaniam addresses difficult topics and makes them understandable through the use of clear prose, useful illustrations and effective repetition. I recommend this book to experienced Java programmers.
Were these reviews helpful? Let us know


Feedback