Name: Java Concurrency in Practice
Availability: InStock
Rating: 9.4 (1 reviews)
Author: Brian Goetz
ISBN: 9780321349606

工作必备，将并发系统的设计思路讲得很明白。

仔细看了遍原版，真心写的很深入！很有帮助。 201605

并发编程入门介绍，相当部分的内容不限于Java。

在并发的世界里，正确不容易~ 居然连全英文电子版都读完了！

如果你想写Java并发程序，这无疑是最好的入门书，讲清楚了一些最重要的东西：模式、性能和Memory Model。

这大概是我近几年读后收获最大的一本书，不过中文版翻译的真是惨无人道、惨绝人寰！强烈建议看原版！

the definitive book of java concurrency programming.

java可以挖掘的东西比想象中要多

又是一本经典的书，同步并发讲得太好太详细了

不搞java了，所以应该不会再读了。书倒是好书。

很不错的关于并发编程的书籍，广度和深度都不错，可以关注书本的作者的一些文章或者博客，都很不错，特别是Doug Lea先生的。

Java 并发编程经典书籍，深入讲解了并发编程的道与术，绝大部分 Java 并发相关的生产问题或者系统设计的解决方案都能在本书中找到答案。

只有当volatile变量能够简化实现和同步策略的验证时，才使用它们。当验证正确性必须推断可见性问题时，应该避免使用volatile变量。正确使用volatile变量的方式包括：用于确保它们所引用的对象的状态的可见性，或...

volatile variables is a weaker form of synchronization, to ensure that updates to a variable are propagated predictably to other threads. When a field is declared volatile, the compiler and runtime...

Task Cancellation An activity is cancellable if external code can move it to completion before its normal completion. There is no safe way to preemptively stop a thread in Java. There are only coop...

Dealing well with failure, shutdown, and cancellation is one of the characteristics that distinguishes a well-behaved application from one that merely works.

看了中文版的这一小节，完全不能理解。拿英文版来对照，才醒悟，原来作者翻译错了！！ 1、首先Effectively不应该翻译成“高效”，而应该翻译成“实际上”。 2、其次，sufﬁcient不应该翻译成“变得很重要”，而...

class OneValueCache { private final BigInteger lastNumber; private final BigInteger[] lastFactors; public OneValueCache(BigInteger i,  BigInteger[] factors) { lastNumber  = i; lastFactors = Arrays....

隐式地允许this引用逸出 public class ThisEscape { public ThisEscape(EventSource source) { source.registerListener(new EventListener() { public void onEvent(Event e) { doSomething(e); } }); } } this...

public class NoVisibility { private static boolean ready; private static int number; private static class ReaderThread extends Thread { public void run() { while(!ready) Thread.yield(); System.out....

package net.jcip.examples; import java.math.BigInteger; import javax.servlet.*; import net.jcip.annotations.*; /** * CachedFactorizer * * Servlet that caches its last request and result * @aut...

可以使用ThreadPoolExecutor构造函数来灵活创建各种不同的线程池。 Executors工具类也提供了好几种工厂方法来创建 特定特征的线程池： newFiexedThreadPool(int nThreads) 使用相同的nThreads指定coreSize与MaxSi...

1, sequential consistency different threads see same exec order. example PossibleReordering: Even if they are executed in order, the timing by which caches are flushed to main memory can make it ap...

1, if possible, use `obj.(wait|notify|notifyAll)` instead of `sleep` `wait` = first, release lock, then, acquire lock after being invoked by timeout or interruption or a `notify` 2, The lock object...

Reentrant? a current lock-holding thread can re-enter lock again. Plus? non-block, Interruptible lock, `tryLock(long, TimeUnit)` Caution? release in `finally`

Dead lock: “dining philoso-phers” problem[cyclic locking dependency] if static/dynamic lock-ordering deadlock ? enforce ordering [Listing 10.2-10.3] Resource deadlocks: connection pools/thread-st...

Saturation policies 1, `executor.setRejectedExecutionHandler()` Extending ThreadPoolExecutor api: thread.task level: `beforeExecute` / `afterExecute` pool level: `terminated` examples: puzzel move

Interruption 1, don't swallow 2, not all methods respond to interrupt. by extends `Thread` and re-write app specific `interrupt` method 3, an encapsulation: `newTaskFor` 4, see github exampls. How ...

what's wrong with java.collections.synchronizedXxx ? 1, unsafe iterator [resolved by deepcopy or client Xxx lock] alternative of java.collections.synchronizedXxx: map -> ConcurrentHashMap: guess @s...

visibility lock = mutual exclusive volatile: = visibility != atomic no cache or shared-cache publish/escape: factory method ensures private refrence !!! An object whose fields are all final may sti...

core: mutable state accessed by multi-threads lock: 1, Mutext: atomic package, synchronized... 2, Reentrancy: semaphore like... Reentrancy means that locks are acquired on a per-thread rather than ...

pros: multi-core or asycho (with nio enabled) hazzard: 1, safty: race condition; 2, liveness: dead lock etc 3, performance

和把整个方法都synchronized相比，这种Open Call为啥能保证不死锁了，没看懂。。。。 @ThreadSafe class Taxi { @GuardedBy("this") private Point location, destination; private final Dispatcher dispatcher;...

"We can use a CompletionService to improve the performance of the page renderer in two ways: shorter total runtime and improved responsiveness. We can create a separate task for downloading each im...

4.2.2. Example: Tracking Fleet Vehicles Note that deepCopy can't just wrap the Map with an unmodifiableMap, because that protects only the collection from modification; it does not prevent callers ...

Hazards: Safety hazard Liveness harzard(deadlock, starvation, livelock)

Java 5.0 improves on the synchronized collections by providing several concurrent collection classes. Synchronized collections achieve their thread safety by serializing all access to the collectio...

If a class is composed of multiple independent thread-safe state variables and has no operations that have any invalid state transitions, then it can delegate thread safety to the underlying state ...

Encapsulating data within an object confines access to the data to the object's methods, making it easier to ensure that the data is always accessed with the appropriate lock held. Confinement make...

Locking can guarantee both visibility and atomicity; volatile variables can only guarantee visibility.

加锁机制既可以确保可见性又可以确保原子性，而 volatile 变量只能确保可见性。
当且仅当满足以下所有条件时，才应该使用 volatile 变量：
- 对变量的写入操作不依赖变量的当前值，或者你能确保只有单个线程更新变量的值。
- 该变量不会与其它状态变量一起纳入到不变性条件中。
- 在访问变量时不需要加锁。

当满足以下条件时，对象才是不可变的：
- 对象创建以后其状态就不可修改
- 对象的所有域都是 final 类型
- 对象时正确创建的（在对象的构造期间，this 引用没有逸出）
从技术上来看，不可变对象并不需要将其所有的域都声明为 final 类型，例如 String 就是这种情况，这就要对类的良性数据竞争情况做精确的分析，因此需要深入理解 Java 的内存模型。... 自己在编码时不要这么做。

对于计算密集的任务，在拥有 N 个处理器的系统上，当线程池大小为 N+1 时，通常能实现最优的利用率。（即使当计算密集型的线程偶尔由于页缺失故障或者其它原因而暂停时，这个“额外”的线程也能确保 CPU 的时钟周期不会被浪费。）对于包含 I/O 操作或者其它阻塞操作的任务，由于线程并不会一直执行，因此线程池的规模应该更大。
计算每个任务对该资源的需求量，然后用该资源的可用总量除以每个任务的需求量，所得结果就是线程池大小的上限。

当任务需要某种通过资源池来管理的资源时，例如数据库连接，那么线程池和资源池的大小将会相互影响。如果每个任务都需要一个数据库连接，那么连接池的大小就限制了线程池的大小。同样，当线程池中的任务是数据库连接的唯一使用者时，那么线程池的大小又将限制连接池的大小。

final域能确保初始化过程的安全性，从而可以不受限制的访问不可变对象，并在共享这些对象时无需同步。

只有当volatile变量能够简化实现和同步策略的验证时，才使用它们。当验证正确性必须推断可见性问题时，应该避免使用volatile变量。正确使用volatile变量的方式包括：用于确保它们所引用的对象的状态的可见性，或者用于标识重要的生命周期事件（比如初始化或关闭）的发生。

To publish an object safely, both the reference to the object and the object's state must be made visible to other threads at the same time. A properly constructed object can be safely published by:

Initializing an object reference from a static initializer;

Storing a reference to it into a volatile field or AtomicReference;

Storing a reference to it into a final field of a properly constructed object; or

Storing a reference to it into a field that is properly guarded by a lock

Our goal is to give readers a set of design rules and mental models that make
it easier—and more fun—to build correct, performant concurrent classes and applications
in Java.

Threads are sometimes called lightweight processes, and most modern operating
systems treat threads, not processes, as the basic units of scheduling.

Using multiple threads can also help achieve better throughput on singleprocessor
systems. If a program is single-threaded, the processor remains idle
while it waits for a synchronous I/O operation to complete. In a multithreaded
program, another thread can still run while the first thread is waiting for the I/O
to complete, allowing the application to still make progress during the blocking
I/O. (This is like reading the newspaper while waiting for the water to boil, rather
than waiting for the water to boil before starting to read.)

Historically, operating systems placed relatively low limits on the number of
threads that a process could create, as few as several hundred (or even less).
As a result, operating systems developed efficient facilities for multiplexed I/O,
such as the Unix select and poll system calls, and to access these facilities, the
Java class libraries acquired a set of packages (java.nio) for nonblocking I/O.
However, operating system support for larger numbers of threads has improved
significantly, making the thread-per-client model practical even for large numbers
of clients on some platforms.

Operating systems evolved to aloowed more than one programm to run at once, running individual programs in processes:isolated, independently executing programs to which the operationg system allocates resources such as memory,file handles, and security credentials. If they needed to,processes could communicate with one another through a variety of coarse-grained communicateion mechanisms:sockets,signal handlers,shared memory,semaphores, and files

The same concerns(resources utilization,fairness,and convenience) that motivated the development of progresses also motivated the development of threads. Threads allow multiple streams of program control flow to coexsit within a progress. They share process-wide resources such as memory and file handles, but each thread has its own program counter,stack, and local variables. Threads also provide a natural decomposition for exploiting hardware parallelism on multiprocessor systems; multiple threads within the same program can be scheduled simultaneously on multiple CPUs.

Informally, an object's state is its data, stored in state variables such as instance or static fields. An object's state may include fields from other, dependent objects; a HashMap's state is partially stored in the HashMap object itself, but also in many Map.Entry objects. An object's state encompasses any data that can affect its externally visible behavior.

在一些大型程序中，要找出多个线程在哪些位置上将访问同一个变量是非常复杂的。幸运的是，面向对象这种技术不仅有助于编写出结构优雅、可维护性高的类，还有助于编写出线程安全的类。访问某个变量的代码越少，就越容易确保对变量的所有访问都实现正确的同步，同时也更容易找出变量再哪些条件下被访问。
程序的封装性越好，就越容易实现程序的县城安全性，并且代码的维护人员也越容易保持这种方式。
完全由线程安全类构成的程序不一定是线程安全的，而在线程安全类中也可以包含非线程安全的类。
正确性的含义是指，某个类的行为与其规范完全一致。在良好的规范中通常会定义各种不变性条件（Invariant）来约束对象的状态，以及定义各种后验条件（Postconditions）来描述对象操作的结果。
任何情况下，只有当类中仅包含自己的状态时，线程安全类才是有意义的。
通常，线程安全性的需求并非来源于对线程的直接使用，而是使用像 Serverlet 这样的框架。
最常见的竞态条件类型就是“先检查后执行”操作，即通过一个可能失败的观测结果来决定下一步的动作。

当执行时间较长的计算或者可能无法快速完成的操作（例如网络IO或控制台IO）时，一定不要持有锁。

无论其她的线程会对已发布的引用执行何种操作，其实都不重要，因为误用该引用的风险始终存在。

如果有人窃取了你的密码并发布到 alt.passwords 新闻组上，那么你的信息将 “逸出”：无论是否有人会恶意地使用这些个人信息，你的账户都已经不再安全了。发布一个引用同样会带来类似的风险。

一种避免使用同步的方式就是不共享数据。如果仅在单线程内访问数据，就不需要同步。这种技术称为线程封闭，它是实现线程安全的最简单方式之一。
在  Swing 中大量使用了线程封闭技术。Swing 的可视化组件和数据模型对象都不是线程安全的，Swing 通过将它们封闭到 Swing 的事件分发线程中来实现线程安全性。

线程封闭技术的另一种常见应用是 JDBC 的 Connection 对象。JDBC 规范并不要求 Connection 对象必须是线程安全的。在典型的服务器应用程序中，线程从连接池中获得一个 Connection 对象，并且用该对象来处理请求，使用完后再将对象返还给连接池。... 这种连接管理模式在处理请求时隐含地将 Connection 对象封闭在线程中。

正如阻塞队列适用于生产者-消费者模式，双端队列同样适用于另一种相关模式，即工作密取（Work Stealing）。在生产者-消费者设计中，所有消费者有一个共享的工作队列，而在工作密取设计中，每个消费者都有各自的双端队列。如果一个消费者完成了自己的双端队列中的全部工作，那么它可以从其它消费者双端队列末尾秘密地获取工作。密取工作模式比传统的生产者-消费者模式具有更高的可伸缩性，这是因为工作者线程不会在单个共享的任务队列上发生竞争。在大多数时候，它们都只是访问自己的双端队列，从而极大地减小了竞争。当工作者线程需要访问另一个队列时，它会从队列的尾部而不是头部获取工作，因此进一步降低了队列上的竞争程度。
工作密取非常适用于既是消费者也是生产者问题—当执行某个工作时可能导致出现更多的工作。例如，在网页爬虫程序在处理一个页面时，通常会发现有更多的页面需要处理。

英文版还是不错的，但是中文版的译者典型的没有技术功底，介绍上说什么专家，我日，他妈狗屁，翻译的非常差劲，有些句子都不通顺，都不知道自己去理解，直接就放在书上，你丫有没有良知，书籍是什么，是希望，是神圣的，你们这些译者简直就是在犯罪 ，不过要是英文功底不好，还...

中文版的翻译者就是个罪犯

请注意这本书叫《Java并发编程实战》，和《Java并发编程实践》是两本书，前者翻译的非常好，后者的翻译我基本看不懂。  本书关于并发编程的细节介绍得非常详细，看得出有很多实践功底，而不是一个理论派，建议每一个学并发的同学看看。

并发编程必读书籍

整体上还是可以看的，不过很多地方看不懂只是因为翻译不恰当。 这本书本身值五颗星。  译文： 一个对象是否需要是线程安全的，取决于它是否被多个线程访问。这指的是程序中访问对象的方式，而不是对象要实现的功能。  原文： Whether an object needs to be thread‐safe depen...

翻译错误真是随处即拾

这本书名为《Java并发编程实践》有些抹杀了它的价值，其中并非只讲述了Java的多线程设施，对一般的并发编程的rationale也有相当透彻的阐述。之前看过各种线程库，pThread, Boost Thread, Java Thread, Qt Thread，感觉Java的线程模型还是相对比较清晰的。只要能读懂一点Java的...

看过的讲并发编程的最清晰的书

之前看到有人推荐这本书，于是就花了将近三个月的时间来看这本书， 前一周在看 《jvm 上的并发编程》，感觉不怎么好，原理没怎么将清楚，晦涩难懂，于是换成这本书，豁然开朗。 虽然现在都是 java8了，这本书里面说的是 java5/6的事情，但是，如果不懂这些，那么 java8中的一些...

不是教你如何使用库，而是教你原理

这本书的前半部分我读的非常仔细，但后半部分则跳跃了很多，并没有完整的阅读。当然原因肯定不是这本书不够好，而是我本人的内力实在是太差了，越看越羞愧。 所谓实践是检验真理的唯一标准，要想理解书上的精髓，唯有多实践，方能有所收获。现在的我越来越感觉自己有些“眼高手...

一段未完的奇妙的旅程

翻译质量不敢恭维，建议不好翻译的地方还是给原文好了；完全没有办法和原版比较，读完后，只能参照原本的一些英文去理解一些关键概念，痛苦呀；  可能翻译者已经完全理解书中的内容，但是翻译时的还要注意一些地方： 1.翻译内容不要假设背景知识 ---读者没有这些背景知识 2.不...

翻译质量太差啦，建议翻译者跳出认知假设来翻译，质量好些

终于读完，对于原著英文版来说，绝对是力荐的。看看作者列表，一个个响亮的名字，这本书的价值就不言而喻了。可贵的是书中不仅仅是详细介绍了jdk5引入的concurrent包的使用和基本原理，并且对线程安全性的设计、性能、死锁和可伸缩性的讨论也蕴含着丰富实践经验。中文版翻...

java并发编程的力作

总体翻译后读起来还是比较顺畅 章节安排，实例演示说明很到位 虽然有些概念不是太深入，但是足矣应付大多数的开发需求 确实实战方面多一些 幸好手头有相关的案例，可以直接修改模拟使用，挺好  Java方面，这是至今看过比较赞的书了！ 超值！

关于多线程和并发讲的很直白

我看过的书不算少, 但是本书是对我帮助最大的.  由于本书难度较高, 不好翻译, 中文版的质量也确实让人不敢恭维. 因此只好硬着头皮啃完英文原版. 当翻完最后一页的时候, 我知道从此之后不会再对英文技术书籍抱有恐惧, 这是我最大的收获.  另外, 从书中学到的知识也很有用, 经常...

第一本啃完的英文书籍

当我第一次阅读易立推荐的《Java并发编程实践》的时候，这只是一本技术参考书，在众多介绍并发程序的书中因为其作者的大名而鹤立鸡群。然而其中对我们生活着这个并行的世界，进行了有趣而丰富的阐述，看似平淡无奇的现象里总是有着深刻而简洁的真理。

充满并行的世界

这本书的组织很有意思 并发编程的核心方法论是什么？一句话，handle shared mutable state correctly 本质是对可变共享状态的管理和维护，这衍生出了一系列方面： 1）模型（内存模型，或者说共享状态管理的依据）； 2）工具：也就是如何利用共享变量，实现各种各样的程序功能；...

JAVA 并发编程的方法论与实践指南

最近在写java服务器端的应用程序，碰到了不少多线程编程的问题。 乘着国庆假期好好的读了一下这本书， 解答了之前工作中说遇到的困惑。机械工业的这个中文版翻译的还可以，虽然译者名单长的有点恐怖，但是确实还没有发现太多的由于翻译导致的理解障碍，当然也可能是因为原著示...

java程序员不得不看的书

翻译太糟糕，有些地方甚至翻译成相反的意思，语言也很啰嗦，甚至不如Google翻译！！！ 例如： 4.1 章节，原文如下： While it is possible to write a thread-safe program that stores all its state in public static fields, it is a lot harder to verify  its  thread  sa...

书是好书，翻译太糟

不可否认原版E文确实很牛X的书。 但是这本书的中文翻译你就是个犯罪者。 我读两三页就得歇息一下然后细细揣摩作者为什么这么翻译。 说实话这是我见过的书里边翻译的最狗血的一本了。 真的需要这本书的，买之前要慎重。

豆瓣评价8.9，我却打了最低分

以下内容均出自本书，短小而深刻：  “所有的并发问题都归结为如何协调访问状态，可变状态越少，就越容易。”  “并发程序中可伸缩性的首要威胁就是独占的资源锁。”  “通常简单性与性能之间会相互牵制，实现一个同步策略时，不要过早地为了性能而牺牲简单性。”  “避免不成...

精彩片断

目前中英两版都读了几章，发表一下个人观点：  五星是给原书打的。劝各位有能力的话读原书吧（网上随手就能找到）。一是原书中有很多术语翻译过来就变味了，二是这个中译版对原文意思的表达不够好。直接读这一中译版很容易让人怀疑自己的理解能力，其实原书写的真的很通俗易懂...

给原书五星，建议有能力的读原书

原书内容本身不错, 但翻译质量堪忧, 有的地方甚至连意思都翻译反了 举个例子, p39 最后一个要求是"正确地构造对象", 这个要求很容易满足, 因为构造函数能使该引用由除了构造函数及其调用者之外的代码来访问" 原文 The last requirement, proper construction, is easily met si...

翻译有点拉

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