Programming Books C Java PHP Python Learn more Browse Programming Books
Programming Concurrency on the JVM and over one million other books are available for Amazon Kindle. Learn more
Buy New
$25.18
Qty:1
  • List Price: $35.00
  • Save: $9.82 (28%)
FREE Shipping on orders over $35.
Only 9 left in stock (more on the way).
Ships from and sold by Amazon.com.
Gift-wrap available.
Add to Cart
Trade in your item
Get a $8.03
Gift Card.
Have one to sell? Sell on Amazon
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 – September 5, 2011

ISBN-13: 978-1934356760 ISBN-10: 193435676X Edition: 1st

Buy New
Price: $25.18
47 New from $19.60 19 Used from $18.60
Amazon Price New from Used from
eTextbook
"Please retry"
Paperback
"Please retry"
$25.18
$19.60 $18.60

Free%20Two-Day%20Shipping%20for%20College%20Students%20with%20Amazon%20Student



Frequently Bought Together

Programming Concurrency on the JVM: Mastering Synchronization, STM, and Actors + Java Concurrency in Practice + Java Performance
Price for all three: $108.97

Buy the selected items together
  • Java Concurrency in Practice $38.48
  • Java Performance $45.31

NO_CONTENT_IN_FEATURE

Shop the New Digital Design Bookstore
Check out the Digital Design Bookstore, a new hub for photographers, art directors, illustrators, web developers, and other creative individuals to find highly rated and highly relevant career resources. Shop books on web development and graphic design, or check out blog posts by authors and thought-leaders in the design industry. Shop now

Product Details

  • Paperback: 280 pages
  • Publisher: Pragmatic Bookshelf; 1 edition (September 5, 2011)
  • Language: English
  • ISBN-10: 193435676X
  • ISBN-13: 978-1934356760
  • Product Dimensions: 1 x 7.5 x 9 inches
  • Shipping Weight: 1.3 pounds (View shipping rates and policies)
  • Average Customer Review: 4.0 out of 5 stars  See all reviews (11 customer reviews)
  • Amazon Best Sellers Rank: #412,938 in Books (See Top 100 in Books)

Editorial Reviews

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.


More About the Author

Dr. Venkat Subramaniam, founder of Agile Developer, Inc., has trained and mentored thousands of software developers in the US, Canada, Europe, and Asia. Venkat helps his clients effectively apply and succeed with agile practices on their software projects. He is a frequent invited speaker at international software conferences and user groups. He's author of .NET Gotchas (O'Reilly), coauthor of the 2007 Jolt Productivity award-winning book Practices of an Agile Developer (Pragmatic Bookshelf),
and author of Programming Groovy (Pragmatic Bookshelf).

Customer Reviews

4.0 out of 5 stars
5 star
5
4 star
3
3 star
2
2 star
0
1 star
1
See all 11 customer reviews
The book is fairly practical and easy to read.
JUG Lugano
There are some wonderful books that address concurrency programming in Java like "Java Concurrency in Practice (JCIP)" from B. Goetz, D. Lea and others.
vrto
It is also the first book I've read that gives any serious guide to using Akka, both from Java and Scala.
D. Fancellu

Most Helpful Customer Reviews

17 of 18 people found the following review helpful By Brian Tarbox on August 31, 2011
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.
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
16 of 20 people found the following review helpful By Steven Barnes on October 25, 2011
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 Comments 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
2 of 2 people found the following review helpful By vrto on February 26, 2013
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.
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
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

Customer Images

Most Recent Customer Reviews

Search

What Other Items Do Customers Buy After Viewing This Item?