---
product_id: 4807691
title: "Java Concurrency in Practice"
price: "€ 96.96"
currency: EUR
in_stock: true
reviews_count: 11
url: https://www.desertcart.gr/products/4807691-java-concurrency-in-practice
store_origin: GR
region: Greece
---

# Java Concurrency in Practice

**Price:** € 96.96
**Availability:** ✅ In Stock

## Quick Answers

- **What is this?** Java Concurrency in Practice
- **How much does it cost?** € 96.96 with free shipping
- **Is it available?** Yes, in stock and ready to ship
- **Where can I buy it?** [www.desertcart.gr](https://www.desertcart.gr/products/4807691-java-concurrency-in-practice)

## Best For

- Customers looking for quality international products

## Why This Product

- Free international shipping included
- Worldwide delivery with tracking
- 15-day hassle-free returns

## Description

Java Concurrency in Practice [Goetz, Brian, Peierls, Tim, Bloch, Joshua, Bowbeer, Joseph, Holmes, David, Lea, Doug] on desertcart.com. *FREE* shipping on qualifying offers. Java Concurrency in Practice

Review: The definitive book on concurrency in Java - Concurrency, in the form of threads, has been present in the Java language from its beginning, and this book is all about concurrency in the current and future versions of Java with an emphasis on writing practical code. This book does for concurrent programming in Java what Geary's series of books did for graphical Java - it moves concurrent Java programming out of the realm of applets containing bouncing balls and into that of providing real solutions for professional programmers. This book is not meant to be an introduction to concurrency in Java. Its intention is to offer practical design rules to assist developers in the difficult process of creating safe, fast, and high-performance concurrent classes. While many of the general concepts in this book are applicable to versions of Java prior to Java 1.5, most of the code examples and all the statements about the Java Memory Model assume Java 1.5 or later. By "later" I mean that some of the code examples use library features added in the not-yet released Java 1.6. After the introduction, which consists of Chapter 1, the book is divided into four parts: Part one, "Fundamentals", (Chapters 2-5) are about the basic concepts of concurrency, thread safety, and composing thread-safe classes from those concurrent building blocks provided by the Java language. Chapter 2, "Thread Safety", and 3, "Sharing Objects", include nearly all of the rules on avoiding concurrency hazards, constructing thread-safe classes, and verifying thread safety. Thus, these chapters emphasize theory and have less code than other chapters in the book. Chapter 4 , "Composing Objects", covers techniques for composing large thread-safe classes from smaller thread-safe classes. Chapter 5, "Building Blocks", covers thread-safe collections and synchronizers, which are the the concurrent building blocks provided by Java. To conclude the section, the authors work through the steps of building an efficient, scalable result cache that could be used in a web server. A summary of the most important rules presented in Part one occur at the end of the section. Part two, "Structuring Concurrent Applications", describes how proper use of threading improves the throughput and responsiveness of concurrent applications. The topics covered in this section include identifying tasks that can be run in parallel and programming them as such, proper termination of tasks, using thread pools for greater efficiency in multi-threaded systems, and finally improving the responsiveness of single-threaded systems, GUI's being the most prominent example. Part 3, "Liveness, Performance, and Testing" is concerned with ensuring that concurrent programs actually do what is expected of them and do so with acceptable performance. The authors describe how to avoid situations where a thread waits forever, also known as a "liveness failure". Also included in this section is an excellent explanation of the use of the "ThreadLocal" class and how it makes it much easier to manage the process of associating a thread with its per-thread data. Part 4, "Advanced Topics", covers issues that will probably be interesting only to experienced developers. These topics include explicit locks, atomic variables, nonblocking algorithms, and developing custom synchronizers. Any of these techniques, explicit locks in particular, can cause chaos when done incorrectly. This book shows how to use these techniques safely and with confidence. One of the things that makes this book so good are the many code examples. There are only snippets of entire programs included in the book itself in order to highlight the portions relevant to the concurrency issue being discussed. The code examples are either good examples, questionable examples, or bad code examples and are decorated with "Smiley Faces" that are either happy, concerned, or unhappy depending on the quality of the code. The full versions of the code examples, as well as supplementary examples and errata, are supposed to be available from the book's website. However, at the time I am writing this, they are not yet available. Overall, I would say that this is the most complete and accessible resource on concurrency in Java I have seen in print. I highly recommend it.
Review: Good book - Although a little bit outdated, it helps you understand the core of multithreading!

## Technical Specifications

| Specification | Value |
|---------------|-------|
| Best Sellers Rank | #149,858 in Books ( See Top 100 in Books ) #7 in Java Programming #66 in Computer Programming Languages #351 in Computer Software (Books) |
| Customer Reviews | 4.8 4.8 out of 5 stars (859) |
| Dimensions  | 7 x 1.2 x 9.2 inches |
| Edition  | 1st |
| ISBN-10  | 0321349601 |
| ISBN-13  | 978-0321349606 |
| Item Weight  | 1.5 pounds |
| Language  | English |
| Print length  | 432 pages |
| Publication date  | May 9, 2006 |
| Publisher  | Addison-Wesley Professional |

## Images

![Java Concurrency in Practice - Image 1](https://m.media-amazon.com/images/I/31IqN5GvrqL.jpg)
![Java Concurrency in Practice - Image 2](https://m.media-amazon.com/images/I/410AjNlz9qL.jpg)
![Java Concurrency in Practice - Image 3](https://m.media-amazon.com/images/I/41gXwMgCXUL.jpg)
![Java Concurrency in Practice - Image 4](https://m.media-amazon.com/images/I/41qC+MVt0HL.jpg)
![Java Concurrency in Practice - Image 5](https://m.media-amazon.com/images/I/510RQlu0x1L.jpg)

## Customer Reviews

### ⭐⭐⭐⭐⭐ The definitive book on concurrency in Java
*by C***E on May 29, 2006*

Concurrency, in the form of threads, has been present in the Java language from its beginning, and this book is all about concurrency in the current and future versions of Java with an emphasis on writing practical code. This book does for concurrent programming in Java what Geary's series of books did for graphical Java - it moves concurrent Java programming out of the realm of applets containing bouncing balls and into that of providing real solutions for professional programmers. This book is not meant to be an introduction to concurrency in Java. Its intention is to offer practical design rules to assist developers in the difficult process of creating safe, fast, and high-performance concurrent classes. While many of the general concepts in this book are applicable to versions of Java prior to Java 1.5, most of the code examples and all the statements about the Java Memory Model assume Java 1.5 or later. By "later" I mean that some of the code examples use library features added in the not-yet released Java 1.6. After the introduction, which consists of Chapter 1, the book is divided into four parts: Part one, "Fundamentals", (Chapters 2-5) are about the basic concepts of concurrency, thread safety, and composing thread-safe classes from those concurrent building blocks provided by the Java language. Chapter 2, "Thread Safety", and 3, "Sharing Objects", include nearly all of the rules on avoiding concurrency hazards, constructing thread-safe classes, and verifying thread safety. Thus, these chapters emphasize theory and have less code than other chapters in the book. Chapter 4 , "Composing Objects", covers techniques for composing large thread-safe classes from smaller thread-safe classes. Chapter 5, "Building Blocks", covers thread-safe collections and synchronizers, which are the the concurrent building blocks provided by Java. To conclude the section, the authors work through the steps of building an efficient, scalable result cache that could be used in a web server. A summary of the most important rules presented in Part one occur at the end of the section. Part two, "Structuring Concurrent Applications", describes how proper use of threading improves the throughput and responsiveness of concurrent applications. The topics covered in this section include identifying tasks that can be run in parallel and programming them as such, proper termination of tasks, using thread pools for greater efficiency in multi-threaded systems, and finally improving the responsiveness of single-threaded systems, GUI's being the most prominent example. Part 3, "Liveness, Performance, and Testing" is concerned with ensuring that concurrent programs actually do what is expected of them and do so with acceptable performance. The authors describe how to avoid situations where a thread waits forever, also known as a "liveness failure". Also included in this section is an excellent explanation of the use of the "ThreadLocal" class and how it makes it much easier to manage the process of associating a thread with its per-thread data. Part 4, "Advanced Topics", covers issues that will probably be interesting only to experienced developers. These topics include explicit locks, atomic variables, nonblocking algorithms, and developing custom synchronizers. Any of these techniques, explicit locks in particular, can cause chaos when done incorrectly. This book shows how to use these techniques safely and with confidence. One of the things that makes this book so good are the many code examples. There are only snippets of entire programs included in the book itself in order to highlight the portions relevant to the concurrency issue being discussed. The code examples are either good examples, questionable examples, or bad code examples and are decorated with "Smiley Faces" that are either happy, concerned, or unhappy depending on the quality of the code. The full versions of the code examples, as well as supplementary examples and errata, are supposed to be available from the book's website. However, at the time I am writing this, they are not yet available. Overall, I would say that this is the most complete and accessible resource on concurrency in Java I have seen in print. I highly recommend it.

### ⭐⭐⭐⭐⭐ Good book
*by K***E on January 19, 2026*

Although a little bit outdated, it helps you understand the core of multithreading!

### ⭐⭐⭐⭐⭐ A decent book on concurrent software engineering
*by S***H on March 25, 2019*

I gave this five stars because as far as I know, this is the *best* book on engineering of highly- or moderately-concurrent software applications. It's the only one I'm aware of that addresses the topic in anything remotely approaching the way I'd like to see it. However, I'm underread in the field. I read the book from the perspective of somebody looking for existing books that cover the topic in the manner I'd like to see it covered. (I haven't found any yet, but this is the best so far.) I think there are lots of improvements that could be made. Obviously, there is some Java-specific stuff in here. Maybe the book suffers the flaw of being friendly to reentrant mutexes, but it has to deal with the Java world. I'd like it to cover 3 times the amount of material. The nicest and most useful thing I can say is: There is no part of this book that is destructively wrong, an abstract banality, or a waste of the reader's time. It's tightly focused, well-written, and in the worst case, it tells you stuff you already know. Highly recommended.

## Frequently Bought Together

- Java Concurrency in Practice
- Effective Java
- Designing Data-Intensive Applications: The Big Ideas Behind Reliable, Scalable, and Maintainable Systems

---

## Why Shop on Desertcart?

- 🛒 **Trusted by 1.3+ Million Shoppers** — Serving international shoppers since 2016
- 🌍 **Shop Globally** — Access 737+ million products across 21 categories
- 💰 **No Hidden Fees** — All customs, duties, and taxes included in the price
- 🔄 **15-Day Free Returns** — Hassle-free returns (30 days for PRO members)
- 🔒 **Secure Payments** — Trusted payment options with buyer protection
- ⭐ **TrustPilot Rated 4.5/5** — Based on 8,000+ happy customer reviews

**Shop now:** [https://www.desertcart.gr/products/4807691-java-concurrency-in-practice](https://www.desertcart.gr/products/4807691-java-concurrency-in-practice)

---

*Product available on Desertcart Greece*
*Store origin: GR*
*Last updated: 2026-02-09*