Hot Best Seller

Java Concurrency in Practice

Availability: Ready to download

"I was fortunate indeed to have worked with a fantastic team on the design and implementation of the concurrency features added to the Java platform in Java 5.0 and Java 6. Now this same team provides the best explanation yet of these new features, and of concurrency in general. Concurrency is no longer a subject for advanced users only. Every Java developer should read th "I was fortunate indeed to have worked with a fantastic team on the design and implementation of the concurrency features added to the Java platform in Java 5.0 and Java 6. Now this same team provides the best explanation yet of these new features, and of concurrency in general. Concurrency is no longer a subject for advanced users only. Every Java developer should read this book." --Martin Buchholz JDK Concurrency Czar, Sun Microsystems "For the past 30 years, computer performance has been driven by Moore's Law; from now on, it will be driven by Amdahl's Law. Writing code that effectively exploits multiple processors can be very challenging. Java Concurrency in Practice provides you with the concepts and techniques needed to write safe and scalable Java programs for today's--and tomorrow's--systems." --Doron Rajwan Research Scientist, Intel Corp "This is the book you need if you're writing--or designing, or debugging, or maintaining, or contemplating--multithreaded Java programs. If you've ever had to synchronize a method and you weren't sure why, you owe it to yourself and your users to read this book, cover to cover." --Ted Neward Author of Effective Enterprise Java "Brian addresses the fundamental issues and complexities of concurrency with uncommon clarity. This book is a must-read for anyone who uses threads and cares about performance." --Kirk Pepperdine CTO, JavaPerformanceTuning.com "This book covers a very deep and subtle topic in a very clear and concise way, making it the perfect Java Concurrency reference manual. Each page is filled with the problems (and solutions!) that programmers struggle with every day. Effectively exploiting concurrency is becoming more and more important now that Moore's Law is delivering more cores but not faster cores, and this book will show you how to do it." --Dr. Cliff Click Senior Software Engineer, Azul Systems "I have a strong interest in concurrency, and have probably written more thread deadlocks and made more synchronization mistakes than most programmers. Brian's book is the most readable on the topic of threading and concurrency in Java, and deals with this difficult subject with a wonderful hands-on approach. This is a book I am recommending to all my readers of The Java Specialists' Newsletter, because it is interesting, useful, and relevant to the problems facing Java developers today." --Dr. Heinz Kabutz The Java Specialists' Newsletter "I've focused a career on simplifying simple problems, but this book ambitiously and effectively works to simplify a complex but critical subject: concurrency. Java Concurrency in Practice is revolutionary in its approach, smooth and easy in style, and timely in its delivery--it's destined to be a very important book." --Bruce Tate Author of Beyond Java " Java Concurrency in Practice is an invaluable compilation of threading know-how for Java developers. I found reading this book intellectually exciting, in part because it is an excellent introduction to Java's concurrency API, but mostly because it captures in a thorough and accessible way expert knowledge on threading not easily found elsewhere." --Bill Venners Author of Inside the Java Virtual Machine Threads are a fundamental part of the Java platform. As multicore processors become the norm, using concurrency effectively becomes essential for building high-performance applications. Java SE 5 and 6 are a huge step forward for the development of concurrent applications, with improvements to the Java Virtual Machine to support high-performance, highly scalable concurrent classes and a rich set of new concurrency building blocks. In Java Concurrency in Practice , the creators of these new facilities explain not only how they work and how to use them, but also the motivation and design patterns behind them. However, developing, testing, and debugging multithreaded programs can still be very difficult; it is all too easy to create concurrent programs that appear to work, but fail when it matters most: in production, under heavy load. Java Concurrency in Practice arms readers with both the theoretical underpinnings and concrete techniques for building reliable, scalable, maintainable concurrent applications. Rather than simply offering an inventory of concurrency APIs and mechanisms, it provides design rules, patterns, and mental models that make it easier to build concurrent programs that are both correct and performant. This book covers: Basic concepts of concurrency and thread safety Techniques for building and composing thread-safe classes Using the concurrency building blocks in java.util.concurrent Performance optimization dos and don'ts Testing concurrent programs Advanced topics such as atomic variables, nonblocking algorithms, and the Java Memory Model


Compare

"I was fortunate indeed to have worked with a fantastic team on the design and implementation of the concurrency features added to the Java platform in Java 5.0 and Java 6. Now this same team provides the best explanation yet of these new features, and of concurrency in general. Concurrency is no longer a subject for advanced users only. Every Java developer should read th "I was fortunate indeed to have worked with a fantastic team on the design and implementation of the concurrency features added to the Java platform in Java 5.0 and Java 6. Now this same team provides the best explanation yet of these new features, and of concurrency in general. Concurrency is no longer a subject for advanced users only. Every Java developer should read this book." --Martin Buchholz JDK Concurrency Czar, Sun Microsystems "For the past 30 years, computer performance has been driven by Moore's Law; from now on, it will be driven by Amdahl's Law. Writing code that effectively exploits multiple processors can be very challenging. Java Concurrency in Practice provides you with the concepts and techniques needed to write safe and scalable Java programs for today's--and tomorrow's--systems." --Doron Rajwan Research Scientist, Intel Corp "This is the book you need if you're writing--or designing, or debugging, or maintaining, or contemplating--multithreaded Java programs. If you've ever had to synchronize a method and you weren't sure why, you owe it to yourself and your users to read this book, cover to cover." --Ted Neward Author of Effective Enterprise Java "Brian addresses the fundamental issues and complexities of concurrency with uncommon clarity. This book is a must-read for anyone who uses threads and cares about performance." --Kirk Pepperdine CTO, JavaPerformanceTuning.com "This book covers a very deep and subtle topic in a very clear and concise way, making it the perfect Java Concurrency reference manual. Each page is filled with the problems (and solutions!) that programmers struggle with every day. Effectively exploiting concurrency is becoming more and more important now that Moore's Law is delivering more cores but not faster cores, and this book will show you how to do it." --Dr. Cliff Click Senior Software Engineer, Azul Systems "I have a strong interest in concurrency, and have probably written more thread deadlocks and made more synchronization mistakes than most programmers. Brian's book is the most readable on the topic of threading and concurrency in Java, and deals with this difficult subject with a wonderful hands-on approach. This is a book I am recommending to all my readers of The Java Specialists' Newsletter, because it is interesting, useful, and relevant to the problems facing Java developers today." --Dr. Heinz Kabutz The Java Specialists' Newsletter "I've focused a career on simplifying simple problems, but this book ambitiously and effectively works to simplify a complex but critical subject: concurrency. Java Concurrency in Practice is revolutionary in its approach, smooth and easy in style, and timely in its delivery--it's destined to be a very important book." --Bruce Tate Author of Beyond Java " Java Concurrency in Practice is an invaluable compilation of threading know-how for Java developers. I found reading this book intellectually exciting, in part because it is an excellent introduction to Java's concurrency API, but mostly because it captures in a thorough and accessible way expert knowledge on threading not easily found elsewhere." --Bill Venners Author of Inside the Java Virtual Machine Threads are a fundamental part of the Java platform. As multicore processors become the norm, using concurrency effectively becomes essential for building high-performance applications. Java SE 5 and 6 are a huge step forward for the development of concurrent applications, with improvements to the Java Virtual Machine to support high-performance, highly scalable concurrent classes and a rich set of new concurrency building blocks. In Java Concurrency in Practice , the creators of these new facilities explain not only how they work and how to use them, but also the motivation and design patterns behind them. However, developing, testing, and debugging multithreaded programs can still be very difficult; it is all too easy to create concurrent programs that appear to work, but fail when it matters most: in production, under heavy load. Java Concurrency in Practice arms readers with both the theoretical underpinnings and concrete techniques for building reliable, scalable, maintainable concurrent applications. Rather than simply offering an inventory of concurrency APIs and mechanisms, it provides design rules, patterns, and mental models that make it easier to build concurrent programs that are both correct and performant. This book covers: Basic concepts of concurrency and thread safety Techniques for building and composing thread-safe classes Using the concurrency building blocks in java.util.concurrent Performance optimization dos and don'ts Testing concurrent programs Advanced topics such as atomic variables, nonblocking algorithms, and the Java Memory Model

30 review for Java Concurrency in Practice

  1. 4 out of 5

    Erika RS

    Every programming language needs to have a book like Java Concurrency in Practice. I usually do not like books about specific programming languages because they tend to become obsolete so quickly. They are so specific to a particular version of a particular language that any small change renders them useless. That is not the case with Java Concurrency in Practice. This book mixes general concurrency background and advice with Java specific advice with advice applicable to only certain versions of Every programming language needs to have a book like Java Concurrency in Practice. I usually do not like books about specific programming languages because they tend to become obsolete so quickly. They are so specific to a particular version of a particular language that any small change renders them useless. That is not the case with Java Concurrency in Practice. This book mixes general concurrency background and advice with Java specific advice with advice applicable to only certain versions of Java. Even as new versions of Java come out, this book will still have value (although not as much as at initial publication). Even as other languages become primary, there are still many parts of the book that will be worth rereading (but not all, which is why I say every language needs its own equivalent of this book). Java Concurrency in Practice reads well. I found myself looking forward to reading it, which is not always the case with technical books. The organization built up knowledge gradually, making sure that a concept or library call was introduced before using it. In fact, the few times something, like join(), was brought up without introduction it was abnormal enough to be memorable. The book starts with an introduction to concurrency. It first motivates the importance of concurrency: from here on out, speed-up comes mostly from having more cores. It then moves on to defining basic concepts such as thread safety, atomicity, locking, liveness, visibility, and publication. I feel like I have a reasonable background with concurrency in theory (although not in practice). Even so, I learned a lot from these introductory chapters. I usually considered concurrency primitives mainly as a way of controlling data access. I had not thought about the their relation to memory visibility, especially in the face of optimizing compilers. The bulk of the book talks about techniques for building thread safe, reasonably performant programs. These rules are meant to make your programs safe and comprehensible. They may not squeeze the last bit of efficiency out of your code, but the authors strongly make the case that such optimization usually is not necessary. Clever tricks may make code faster, but they make it more likely to be wrong and harder to maintain. Furthermore, in the face of program optimization, hand tuned code may end up being slower than more naive code that has been optimized. Instead, the authors advice programmers to write easy to understand and safe programs first and then find and optimize the bottlenecks. These range from low level rules such as favoring immutable objects whenever possible to high level guidance on how to structure programs (e.g., how fine grained should your concurrency be? Threads and context switching, while relatively cheap, are not free.) Part of what makes this book great, however, is that the authors do not treat you like you are stupid. After spending most of the book helping you to understand the complexities of concurrency, they spend the last part of the book giving you the tools to shoot yourself in the foot. They realize that, just as sometimes it really is worth it to write assembly, sometimes performance requirements force you to use higher risk concurrency techniques. In this vein, the last chapters discuss explicit locks, custom synchronizers, nonblocking synchronization, and the Java memory model. I highly recommend Java Concurrency in Practice to any Java programmer. Even if you are not explicitly using concurrency in your code, it shows up implicitly in enough libraries that it is worth reading at least the first part of the book. If you primarily program in another language, I would recommend that you find the equivalent book for your language of choice. Understanding concurrency is quickly becoming required knowledge for programmers.

  2. 4 out of 5

    Michael

    Wow, this was a damn fine book. For anyone exposed to the pre-Java5 concurrency support (implicit locking and volatile) this is an eye-opener. Goetz and company systematically deconstruct a bevy of poorly constructed "concurrent" source and provide tips and approaches to simplify concurrency in Java. The #1 point to take from this book is to avoid mutable data structures at all costs. Easier said than done of course, but much easier than lock-based concurrency. -m

  3. 5 out of 5

    Michael Koltsov

    It was quiet easy to review this book, because i try to re-read it every year and it had became a necessity for me. Some parts of it are not easy to comprehend but at the end of the day this book can teach you what no other book could. This time i’ve created a repository that contains most of the examples. In my experience writing code helps me much more than reading code. My score 5/5

  4. 4 out of 5

    Algirdas Raščius

    Every Java developer should read this book. There is a lot to learn from this book. And there is a lot of bad concurrent code written. World would be noticeably better, if every Java developer read this book before writing any concurrent code :)

  5. 4 out of 5

    Caroline

    Before I read this book, I thought, I already understand concurrency. How much Java-specific stuff can there be to learn? If I want to use some library, e.g. ConcurrentHashMap, I'll read its documentation before I use it. That should be good enough. I was wrong. Partly this is because I didn't actually understand concurrency as well as I thought. I was used to thinking in terms of interleavings and ignoring reordering, which is insufficient! This led to some big surprises when reading possible pr Before I read this book, I thought, I already understand concurrency. How much Java-specific stuff can there be to learn? If I want to use some library, e.g. ConcurrentHashMap, I'll read its documentation before I use it. That should be good enough. I was wrong. Partly this is because I didn't actually understand concurrency as well as I thought. I was used to thinking in terms of interleavings and ignoring reordering, which is insufficient! This led to some big surprises when reading possible program outputs in this book. But there was also a lot of stuff specific to the Java memory model covered here that I didn't know about, such as safe publication. I'd say this book, or something else with equivalent Java-specific info, is a must-read for anyone developing concurrent programs in Java.

  6. 4 out of 5

    Will

    Until I read this book, I was stuck on the early model of concurrent programming in Java. Basically, you had threads and you had synchronized methods. The performance characteristics of thread scheduling and lock acquisition were questionable in the early virtual machines, so I never bothered with them. The situation improved dramatically in Java 5, and Goetz et al. cover all the ins and outs. Java Concurrency in Practice is much more than a reference to programming libraries and would be useful Until I read this book, I was stuck on the early model of concurrent programming in Java. Basically, you had threads and you had synchronized methods. The performance characteristics of thread scheduling and lock acquisition were questionable in the early virtual machines, so I never bothered with them. The situation improved dramatically in Java 5, and Goetz et al. cover all the ins and outs. Java Concurrency in Practice is much more than a reference to programming libraries and would be useful to anyone who knew Java and needed to understand parallel computing. The general principles should apply to other languages with little lost in translation. I read this book as a precursor to learning Clojure, a Lisp dialect that runs on the Java virtual machine, to better understand and appreciate its concurrency model. Some complaints: * At times, it's obvious that the book was the product of several authors. * The forward references get in the way of an initial reading. * The tenor of the book takes a few chapters to build and the organization is mysterious for awhile. * You'll need to read the text closely and think about the examples to identify a set of "best practices." The authors give general guidelines but refrain from providing ready-made templates. That can be a problem if you just want to find a good starting point for your own code. If you're a Java programmer, read this book. If you're a programmer who knows Java and who isn't familiar with approaches to concurrent execution, read this book. If you don't know Java, then this is not the place to start.

  7. 4 out of 5

    Ian Nelson

    This is an amazing book from both the software engineering and computer science perspectives. Having not learned much about concurrency from my degree program, and wanting to learn more, I turned to this book as a reference. There have been many reviews on this text, most positive, and I can definitely see why. Although there is a *lot* of content to cover, it is very in-depth, and provides many examples to work through all of the conditions and failures that one may encounter.

  8. 5 out of 5

    Paul

    Anyone that even semi-seriously considers themselves a java programmer should have read this book, probably multiple times.

  9. 4 out of 5

    Marcin

    Book wonderfully covers ins and outs of concurrent programming in Java. Unfortunately, this book has won its renown due to one crucial factor - it one of the very few books covering this topic to such extent. Following this - the situation in which one-eyed is the king in the land of the blind is more than visual. First and most definite problem with this book is the organisation of the material. To fully understand this book you have to read it at least twice. Why? Throughout the book the refere Book wonderfully covers ins and outs of concurrent programming in Java. Unfortunately, this book has won its renown due to one crucial factor - it one of the very few books covering this topic to such extent. Following this - the situation in which one-eyed is the king in the land of the blind is more than visual. First and most definite problem with this book is the organisation of the material. To fully understand this book you have to read it at least twice. Why? Throughout the book the references to the forthcomming material are more than frequent. Either reorganising the material or giving reader basic information about the forthcomming material just in the place of its mentioning would diminish the severance of this problem. Secondly, the book -being authored by the experts in the field - lack in detailed explanations of particular topics. While one sentence is more than enough for an expert, event a vivid and willingfull learner could feel like being left alone. Thirdly, there are no exercises in the book, so there is no virtually no way to check the understanding of the material. A chapter on the theoretical concepts of concurrency would be as well beneficial. To some extent this disadvantages might be assigned to almost any technical book. Unfortunately, in case of JCiP they are more visual as nowadays almost all Java devs are focused on web solutions, so they usually have neither knowledge nor experience in the concurrent programming. The aforementioned disadvantages of the book make it practically unreachable for standard Java dev to read it with full understanding.

  10. 4 out of 5

    Jack Repenning

    This is a really crucial book for any Java developer. You may not realize you need it, but man oh man, you do![return][return]The Java culture and language development contain a trap: whereas it once was a commonplace that concurrent programming was too hard for "ordinary" developers, Java made it easy to do, and even in the beginning reasonably easy to do successfully.[return][return]Times have changed. Java programs used to run on uniprocessor machines (where "concurrency" is more an aspiratio This is a really crucial book for any Java developer. You may not realize you need it, but man oh man, you do![return][return]The Java culture and language development contain a trap: whereas it once was a commonplace that concurrent programming was too hard for "ordinary" developers, Java made it easy to do, and even in the beginning reasonably easy to do successfully.[return][return]Times have changed. Java programs used to run on uniprocessor machines (where "concurrency" is more an aspiration than a reality), and the Java virtual machine used to be relatively simple. Nowadays, even an inexpensive laptop has at least two cores, and can achieve real concurrency among half a dozen Java threads. The JVM has evolved aggressively to use this power, taking liberal advantage of feature always contained in the Java language specifications, but until now not necessary embodied in the JVM implementation. As a result, more and more, your programs do not mean what they appear to mean, and less and less are you free to presume they do.Fortunately, the principal and supporting authors here are the powerful minds behind the growth of the JVM's concurrency capabilities. And, a bit miraculously, these great minds, deeply embedded in this complex code, can and do explain its surprises and mastery in a way that should be accessible to any competent programmer. This is not "for Dummies" stuff, but it's also "not rocket science" (quite). You can handle this.[return][return]And, you must.

  11. 5 out of 5

    Thomas

    I've actually read a significant portion of this already, but leaving it in my on-hold queue for now since I really want to finish all of it and revisit a few key parts. I can say that if you're doing anything concurrent on the JVM (and chances are that if you're doing anything on the JVM, you are), you should read this. It's a fantastic introduction to the mechanics of the system. Everything else you will find out there that presents alternate concurrency approaches (Akka, RxJava, etc.) builds I've actually read a significant portion of this already, but leaving it in my on-hold queue for now since I really want to finish all of it and revisit a few key parts. I can say that if you're doing anything concurrent on the JVM (and chances are that if you're doing anything on the JVM, you are), you should read this. It's a fantastic introduction to the mechanics of the system. Everything else you will find out there that presents alternate concurrency approaches (Akka, RxJava, etc.) builds on these basic underlying mechanics and understanding how they work will be an immense help.

  12. 4 out of 5

    Yaroslav Dremanovich

    It took too much time to read it .. but it contains many theoretical parts and helps to set your mind in thinking in multi threads realty.. So, you will know how to safe publish objects, persist correctness of your program and speed up your program if it applicable by hardware.. One needs to read it once (no more). Despite that the book issued in 2006 - it is still actual in terms of manual handle of synchronization. As for today - better way to improve performance of your code is to use JavaRx s It took too much time to read it .. but it contains many theoretical parts and helps to set your mind in thinking in multi threads realty.. So, you will know how to safe publish objects, persist correctness of your program and speed up your program if it applicable by hardware.. One needs to read it once (no more). Despite that the book issued in 2006 - it is still actual in terms of manual handle of synchronization. As for today - better way to improve performance of your code is to use JavaRx stack (but is has some disadvantages described in this book). So... I recommend to read it once at least.

  13. 4 out of 5

    Jevgeni Holodkov

    The book is definitely worth reading even if you do only develop enterprise applications, which get most of the concurrency from the application servers (at least will you understand how it works). You will get a deep understanding how does java.util.concurrent api works, why it is needed and when to apply one or another technique. The book is full of examples, guiding a reader from "bad" solutions to "better" and "best" solutions. Concurrency idioms are very well covered. I gave this book 5 sta The book is definitely worth reading even if you do only develop enterprise applications, which get most of the concurrency from the application servers (at least will you understand how it works). You will get a deep understanding how does java.util.concurrent api works, why it is needed and when to apply one or another technique. The book is full of examples, guiding a reader from "bad" solutions to "better" and "best" solutions. Concurrency idioms are very well covered. I gave this book 5 star, which means that there are really a lot of wisdom, so I would reread the book some day again.

  14. 4 out of 5

    Craig

    As far as books on key programming topics go, this one is a gem. Insightful, relevant, and well written, serious Java developers ought to check this one out. Many of stickiest programming issues relate to threading or concurrency issues, and this book really comes through in outlining common mistakes, and offering great tips and solutions for the most common types of threading/asynchronous issues that tend to plague us.

  15. 5 out of 5

    Glen

    Very well done. Full of useful information, suggestions, and examples. I bought it for a specific question, found the answer right away and it was perfect! I could have tried much more complicated things, but this provided a simple solution that saved me a lot of time. I did not read it cover to cover.

  16. 4 out of 5

    Emil Petkov

    Brian Goetz is a concurrency czar - this gem taught me a lot about multicore development, non-blocking algorithms, threads, etc. The book is so deep and yet so practical that most of the other pieces on threading/concurrency seem like part of the "For Dummies" series.

  17. 5 out of 5

    Kenneth Blomqvist

    Goes into all the details of concurrent programming and explains the Java memory model and it's guarantees. Highly recommended to any developer writing concurrent software (even if you don't use Java).

  18. 5 out of 5

    Martin Asenov

    Java concurrency in practice is one of the best programming-related books I have ever read (perhaps along with Effective Java, Java Puzzlers and Martin Fowler's refactoring).

  19. 4 out of 5

    Irakli Kobiashvili

    The very best book about this topic. I learned lot from this book - thanks to authors.

  20. 5 out of 5

    Nitin

    Must read for every java programmer

  21. 4 out of 5

    Andrew Barchuk

    Very solid book despite not covering some more recent topics like fork-join concurrency, parallel Java 8 streams and RxJava.

  22. 4 out of 5

    Larry

    I've heard this book referenced countless times in my career but never bothered to read it because I wasn't writing Java. Now I wish I had read it sooner.

  23. 4 out of 5

    Xanan

    This is not an introduction to Java Concurrency. This is not a taxonomic reference-like book that describes the Java Concurrency APIs either. Rather it is a skilled guide on how to take advantage of the concurrency APIs and constructs to avoid the intricacies and difficulties of concurrent programming. The reading is technically advanced. The approach followed often involves presenting concurrency issues, exposing the associated pitfalls with a wrong solution and refining it to properly address the This is not an introduction to Java Concurrency. This is not a taxonomic reference-like book that describes the Java Concurrency APIs either. Rather it is a skilled guide on how to take advantage of the concurrency APIs and constructs to avoid the intricacies and difficulties of concurrent programming. The reading is technically advanced. The approach followed often involves presenting concurrency issues, exposing the associated pitfalls with a wrong solution and refining it to properly address the issue. The reader should be prepared to peruse the Javadoc to complement what is explained in the book and get the full picture of the available APIs. Thread pools are given ample coverage and thoroughly analyzed (usage, alternative implementations, sizing, configuration, task cancellation, shutdown). High level (synchronized collections, semaphores, latches, barriers) as well as low level (locks, condition variables, atomic variables) synchronization are covered. The book predates Java 7 so recent additions like the Fork/Join framework and CompletableFuture are not discussed. Concurrency issues involved with Java 8 streams are also missing. Despite the fact that an update would certainly be appreciated, readers can still considerably benefit from the book contents.

  24. 5 out of 5

    Robert

    One of the few must read books for anbody writing Java for a living. Before this books I was only vaguely aware of the pitfalls with concurrency in Java. The first part of the book "Fundamentals" helped me understand the concepts involved and put my reasoning about concurrent code on a more solid foundation. The second part of the book are about structuring using the executor framework, which is also interesting if you have never work with it before. But for me the real value came from the first One of the few must read books for anbody writing Java for a living. Before this books I was only vaguely aware of the pitfalls with concurrency in Java. The first part of the book "Fundamentals" helped me understand the concepts involved and put my reasoning about concurrent code on a more solid foundation. The second part of the book are about structuring using the executor framework, which is also interesting if you have never work with it before. But for me the real value came from the first part and some of the advanced topics in part 3 like livness hazards. If you work with multithreaded Java applications and can't answer one of these questions "what exactly does the volataile modifier do?", "what establishes a happens-before relationship?", "what constitutes safe publication?", or "why is double checked locking bad?" it is time to read this book!

  25. 4 out of 5

    Madhur Bhargava

    This book is the final word on threading and concurrency in Java. I always thought concurrency was a bit tricky but this book really takes it to the next level. The author provides a thorough explanations of the under the hood workings of Java Concurrency & the JMM. Some of the explanations in the book can stump even the expert Java programmers with several 'Aha' moments. I specifically enjoyed the last chapter which highlights the main points of JSR 133 & JMM. Truly a must read for any serious This book is the final word on threading and concurrency in Java. I always thought concurrency was a bit tricky but this book really takes it to the next level. The author provides a thorough explanations of the under the hood workings of Java Concurrency & the JMM. Some of the explanations in the book can stump even the expert Java programmers with several 'Aha' moments. I specifically enjoyed the last chapter which highlights the main points of JSR 133 & JMM. Truly a must read for any serious Java Programmer.

  26. 5 out of 5

    Brian

    (4.5) Good to have read once, more detail than can be absorbed in one go, probably good reference but we’ll see Remains to be seen whether this will be useful as reference for a specific scenario or question I run into, but I’m optimistic. Haven’t written multi-threaded Java in a looooooong time and much has changed, and this really helped me to catch up. So much less wild-west, which feels comforting. I do wonder how much of this is true/applicable now, but soon will not be (even if we stick with (4.5) Good to have read once, more detail than can be absorbed in one go, probably good reference but we’ll see Remains to be seen whether this will be useful as reference for a specific scenario or question I run into, but I’m optimistic. Haven’t written multi-threaded Java in a looooooong time and much has changed, and this really helped me to catch up. So much less wild-west, which feels comforting. I do wonder how much of this is true/applicable now, but soon will not be (even if we stick with Java/JVM languages for a while).

  27. 5 out of 5

    Isidro López

    This was my third attempt in the last 10 years to read it... and finally succeeded, yuhuu :-D It's that kind of book where you think: "How have I been able to work without reading it?" ^___^ I feel that even in 2019 it brings a lot of value, many things still apply. On the other hand, is far away from a beginner-intermediate book, I would only recommend it to people who have been working with Java for several years.

  28. 5 out of 5

    Viraj Bhosle

    Must for understanding Java multi-threading. Java Concurrency in Practice explains multi-threading clearly with examples. It show how we can build complex and robust multi-threading code by using simple building blocks. This books gave me confidence to write concurrent code, enlightened me about all the pitfalls.

  29. 4 out of 5

    DANIEL

    One of the best books about concurrency in Java. It explains in a really clear way the whole concepts about this dense topic. It is full of code examples and, if you want to understand how to manage the concurrency in Java in a low level, you have to read it. Recommended 100%

  30. 5 out of 5

    Dimos Raptis

    A must for every Java developer, it explains a rather complicated aspect of computer science in a quite simplified way. Not sure how up-to-date it will be in the next years with new APIs & abstractions coming out. A must for every Java developer, it explains a rather complicated aspect of computer science in a quite simplified way. Not sure how up-to-date it will be in the next years with new APIs & abstractions coming out.

Add a review

Your email address will not be published. Required fields are marked *

Loading...
We use cookies to give you the best online experience. By using our website you agree to our use of cookies in accordance with our cookie policy.