Java 9 并发编程实战

出版者:人民邮电出版社

作者:Javier Fernández González

页数:0

出版时间:2019-8

价格:0

isbn号码:9787115505866

作者简介

Javier Fernández González 是一名有着超过 10 年 Java 技术经验的软件架构师。他曾过担任过教师，研究员，程序员和分析员，现在是 Java 项目、特别是 J2EE 相关项目的架构师。在担任教师期间，他在 Java 、 J2EE 和 Struts 框架上有超过 1,000 个小时的教学时间。当研究员时，他曾在信息检索领域，用 Java 开发应用程序来处理大量的数据，并且是一些期刊文章及和会议演示的合作者。近些年来，他在不同的领域（比如公共行政，保险，医疗保健，交通，等等）为不同的客户开发 J2EE Web 应用程序。目前，他在欧洲最大的咨询公司（Capgemini，凯捷）担任软件架构师，为保险公司开发和维护应用程序。

目录信息

第 1章 线程管理 1
1.1 简介 1
1.2 线程的创建、运行和设置 2
1.3 线程中断 8
1.4 控制线程中断 11
1.5 线程的休眠和唤醒 14
1.6 等待线程执行结束 16
1.7 守护线程的创建与运行 19
1.8 处理线程中的不可控异常 23
1.9 使用线程本地变量 26
1.10 线程分组及线程组中不可控异常的处理 29
1.11 使用工厂创建线程 33
第 2章 线程同步基础 37
2.1 简介 37
2.2 方法同步 38
2.3 在同步代码块中使用条件 46
2.4　在同步代码块中使用锁机制 51
2.5 用读/写锁保护同步代码块 57
2.6 在一个锁中使用多个条件 62
2.7 高阶知识：StampedLock的使用 70
第3章 线程同步工具 78
3.1 简介 78
3.2 控制对资源的一个或多个副本的并发访问 79
3.3 等待多个并发事件 85
3.4 在指定状态点同步任务 90
3.5 运行阶段性并发任务 98
3.6 阶段性并发任务中阶段转变的控制 108
3.7 两个并发任务间的数据交换 114
3.8 异步地完成和关联任务 118
第4章 线程执行器 128
4.1 简介 128
4.2 创建一个线程执行器并实现其拒绝策略 129
4.3 在一个执行器里执行任务并返回结果 136
4.4 运行多个任务并处理第 一个返回结果 140
4.5 运行多个任务并处理全部返回结果 146
4.6 在执行器内延迟运行任务 150
4.7 在执行器内周期性地运行任务 154
4.8 在执行器内取消任务 157
4.9 在执行器内控制任务的完成 160
4.10 在执行器内分离任务的启动并处理返回结果 164
第5章 fork/join框架 171
5.1 简介 171
5.2 创建一个fork/join池 173
5.3 合并任务的执行结果 180
5.4 异步地运行任务 189
5.5 在任务中抛出异常 196
5.6 取消一个任务 200
第6章 并行反应式流 208
6.1 简介 208
6.2 使用不同的源创建流 210
6.3 归约一个流的元素 217
6.4 收集流中的元素 224
6.5 把一个动作应用到流的每个元素上 231
6.6 过滤流中的元素 234
6.7 转换流中的元素 237
6.8 排序流中的元素 241
6.9 在流中的元素上验证条件 244
6.10 在反应式流上反应式编程 248
第7章 并发集合 256
7.1 简介 256
7.2 运用非阻塞线程安全的双端队列 257
7.3 运用阻塞线程安全的双端队列 262
7.4 运用按优先级排序的阻塞线程安全队列 265
7.5 运用带延迟元素的线程安全列表 271
7.6 运用线程安全的跳表 276
7.7 运用线程安全的HashMap 281
7.8 运用原子性变量 287
7.9 运用原子性数组 294
7.10 运用volatile关键字 298
7.11 运用变量句柄 302
第8章 自定义并发类 307
8.1 简介 307
8.2 自定义ThreadPoolExecutor类 308
8.3 实现一个基于优先级的Executor类 313
8.4 实现ThreadFactory接口来生成自定义线程 317
8.5 在一个Executor对象中使用ThreadFactory 322
8.6 自定义在一个周期调度性线程池中运行的任务 324
8.7 实现一个ThreadFactory以生成fork/join框架的自定义线程 331
8.8 自定义运行于fork/join框架中的任务 338
8.9 实现一个自定义Lock类 342
8.10 实现一个基于优先级的传递队列 348
8.11 实现自己的原子性对象 359
8.12 实现自己的流生成器 363
8.13 实现自己的异步流 369
第9章 并发程序的测试 378
9.1 简介 378
9.2 监测Lock接口 379
9.3　监测Phaser类 383
9.4　监测Executor框架 387
9.5 监测fork/join任务池 390
9.6 监测流 395
9.7　输出有效日志信息 397
9.8　利用FindBugs分析并发程序代码 402
9.9　使用Eclipse调试并发程序代码 406
9.10　使用NetBeans调试并发程序代码 408
9.11 使用MultithreadedTC调试并发程序代码 413
9.12 使用JConsole监测 416
第 10章 附加信息 421
10.1 简介 421
10.2 在Executor框架中处理Runnable对象的结果 421
10.3 在ForkJoinPool类中处理未控制的异常 427
10.4 使用线程安全的阻塞队列在生产者和消费者之间进行交互 431
10.5 监测Thread类 436
10.6 监测Semaphore类 440
10.7 生成并发随机数 443
第 11章 并发编程设计 445
11.1 简介 445
11.2 尽可能使用不可变对象 446
11.3 对锁排序以避免死锁 449
11.4 使用原子变量替代同步 451
11.5 尽可能短地持有锁 455
11.6 委托执行器管理线程 459
11.7 使用并发数据结构替代手动编程 462
11.8 使用延迟初始化预防问题 464
11.9 使用fork/join框架替代执行器 466
11.10 避免在锁中使用阻塞操作 470
11.11 避免使用已弃用的方法 472
11.12 使用执行器替代线程组 473
11.13 使用流处理大数据集 474
11.14 其他提示和技巧 479
· · · · · · (收起)

读后感

我看的是英文原版，中文版翻译的如何不知道。与评分很高的 Java并发编程实战 相比，这本书 并没有讲 并发的理论。而是通过一个个的示例 来告诉你怎样 照葫芦画瓢 用多线程/Executors/ForkJoin/ 写出一个可Run的多线程处理程序。书中的示例程序讲解的很仔细（解释每部分代码用...  

P151 Finally, you can configure the behavior of the ScheduledThreadPoolExecutor class when you call the shutdown() method and there are pending tasks waiting for the end of their delay time. The default behavior is that those tasks will be executed despite ...  

P151 Finally, you can configure the behavior of the ScheduledThreadPoolExecutor class when you call the shutdown() method and there are pending tasks waiting for the end of their delay time. The default behavior is that those tasks will be executed despite ...  

后悔啊 应该看原版后悔啊 应该看原版后悔啊 应该看原版后悔啊 应该看原版后悔啊 应该看原版后悔啊 应该看原版后悔啊 应该看原版后悔啊 应该看原版后悔啊 应该看原版后悔啊 应该看原版后悔啊 应该看原版后悔啊 应该看原版后悔啊 应该看原版后悔啊 应该看原版后悔啊 应该看原版后...  

没有讲并发原理，实实在在的实例讲学，脱离了低级趣味的纯粹的cookbook。。 对多线程和并发的理论不是很扎实的可以看看这本书，看完之后，你对并发的理论可能也没啥进步。。 有些书根本没必须要写那么多字，你搞这个要求干嘛。。。 有些书根本没必须要写那么多字，你搞这个要...

用户评价

“Java 9 并发编程实战”这本书，对于我这个长期在 Java 生态中摸爬滚打的开发者来说，无疑是一份宝贵的财富。我尤其赞赏作者在撰写过程中所体现出的严谨性。书中引用的每一个例子，都经过了细致的推敲和验证，确保其正确性和代表性。对于一些容易产生误解的细节，作者都会不厌其烦地进行解释，并辅以图示，让读者能够清晰地理解。 我记得在阅读关于内存屏障（Memory Barrier）和happens-before原则的章节时，我曾一度感到困惑。但作者通过生动的比喻和详细的图解，将这个抽象的概念变得容易理解。他解释了为什么在多线程环境下，CPU 的乱序执行和指令重排会影响程序的正确性，以及 happens-before 原则如何为我们提供了一种确定性的并发模型，让我们可以安全地编写多线程程序。这让我深刻地认识到，并发编程不仅仅是关于同步，更重要的是对底层内存模型和指令执行过程的深刻理解。

这本书不仅仅是理论的堆砌，更重要的是它充满了实践的智慧。作者在讲解每一个并发概念或技术时，都会紧密结合实际的应用场景。例如，在介绍 `CountDownLatch` 时，他举了一个例子，说明如何使用它来协调多个线程同时开始执行某个任务，并且在所有线程都完成后，主线程再继续执行。这个简单的例子，却能让我们迅速领会到 `CountDownLatch` 的核心作用。 我尤其喜欢书中关于如何避免并发编程中常见错误的讨论。作者列举了很多新手在编写并发代码时容易犯的错误，比如忘记释放锁、使用不当的同步机制、或者对原子性操作的误解。他不仅指出了这些错误，更重要的是，他给出了如何避免这些错误的具体方法和建议，甚至还展示了如何使用一些工具（如 JProfiler）来检测和定位并发问题。这对于我这样希望提高代码质量和健壮性的开发者来说，非常有价值。

这本书的作者在并发编程领域的经验无疑是非常丰富的。我尤其欣赏他在处理复杂并发场景时展现出的那种细致入微的分析能力。例如，在讲解死锁的产生原因和避免策略时，他不仅仅停留在理论层面，而是通过剖析一些经典的死锁案例，详细地阐述了导致死锁的四个必要条件（互斥使用、请求与保持、不剥夺、循环等待），并给出了如何通过调整线程的锁获取顺序、使用超时锁、或者引入死锁检测机制来规避这些问题。更让我印象深刻的是，他在讲解过程中，时不时会穿插一些“坑”的提醒，比如在并发场景下，一些看似简单的操作（如 `ArrayList` 的 `add()` 方法）如果缺乏适当的同步，就可能导致数据不一致的问题，这让我受益匪浅。 书中关于 `Fork/Join` 框架的章节也让我眼前一亮。在现代多核处理器日益普及的今天，如何有效地利用多核并行处理能力是并发编程的一个重要课题。`Fork/Join` 框架提供了一种声明式的编程模型，可以将一个大任务分解成多个小任务，然后并行执行，最终将结果合并。作者通过一些实际的例子，例如并行计算斐波那 চুক্তি数列、并行排序，清晰地展示了 `Fork/Join` 框架的使用方法，以及如何编写高效的 `RecursiveTask` 和 `RecursiveAction`。让我对如何构建大规模并行应用有了更深入的认识，也对如何利用 CPU 的计算能力有了新的思路。

“Java 9 并发编程实战”这本书，给我的感觉是，它不仅仅是一本技术手册，更像是一位经验丰富的导师在引导你逐步深入并发编程的殿堂。作者在讲解的过程中，始终保持着一种“启发式”的教学风格，他不会直接给出答案，而是通过提出问题、分析问题，然后引导读者去思考，去发现解决方案。这种学习方式，极大地激发了我的主动性和求知欲。 令我印象深刻的是，书中关于使用 `CompletableFuture` 来构建异步和响应式应用的章节。作者通过一系列的示例，展示了如何利用 `CompletableFuture` 来处理非阻塞的 I/O 操作，如何链式调用多个异步任务，以及如何处理异常。这让我对如何构建高性能、可伸缩的应用程序有了更清晰的认识，尤其是在处理大量并发请求的场景下，`CompletableFuture` 的优势尤为明显。

这本书的排版和设计也值得称赞。清晰的章节划分，适度的留白，以及高质量的代码示例，都为阅读带来了极大的便利。作者在代码注释方面也做得非常到位，很多关键的实现细节都会有详细的注释说明，这大大减少了我们阅读代码时的理解难度。 我最喜欢的是，书中提供的许多“最佳实践”建议。这些建议不仅仅是停留在理论层面，而是基于作者在实际项目中的经验总结。例如，关于如何编写可测试的并发代码、如何进行并发性能调优、以及如何处理并发异常等，都为我提供了宝贵的指导。这些实践性的建议，让我能够将书中学到的知识，更有效地应用到实际工作中，写出更稳定、更高效的并发程序。

这本书给我最深刻的印象是，它在讲解高阶并发概念时，依然能够保持清晰和易懂。作者在处理像 CAS（Compare-And-Swap）操作、无锁数据结构（Lock-Free Data Structures）以及原子变量（Atomic Variables）等复杂主题时，并没有使用过于深奥的术语，而是通过形象的比喻和细致的代码分析，将这些概念的原理和应用场景娓娓道来。 特别是我对原子变量的理解，在这本书的帮助下得到了极大的提升。我过去一直认为，只需要使用 `synchronized` 关键字就可以解决所有并发问题，但这本书让我认识到，在某些场景下，原子变量可以提供更优的性能，因为它避免了线程阻塞。作者详细讲解了 `AtomicInteger`、`AtomicLong`、`AtomicReference` 等类，并展示了如何使用它们来实现高效的计数器、原子更新等功能。这让我对并发编程有了更广泛的视野。

这本书在讲述并发编程的“术”的同时，也深入地探讨了“道”。我指的是，作者在介绍各种并发工具和技术时，并没有止步于“如何使用”，而是花了大量篇幅去解释“为什么这么设计”、“背后的原理是什么”。例如，在讲解 `ConcurrentHashMap` 的实现原理时，他详细地分析了分段锁（Segment locking）机制，以及如何通过细粒度的锁来提高并发访问的性能，这让我对 Java 集合类在并发场景下的强大能力有了全新的认识。 此外，书中关于并发安全与性能权衡的讨论也让我印象深刻。作者多次强调，在并发编程中，性能优化和线程安全是需要仔细权衡的两个方面。他通过一些实际的例子，展示了如何在保证线程安全的前提下，最大化系统的吞吐量，以及在某些情况下，适当的牺牲一些性能来换取更高的并发安全性是明智的选择。这种辩证的思维方式，让我对并发编程有了更全面、更成熟的理解，避免了陷入“一味追求极致性能”的误区。

“Java 9 并发编程实战”这本书，给我的感觉是，它不是那种“看完就忘”的书，而是可以反复研读，每一次都会有新的体会。作者在讲解一些高级主题时，比如 actor 模型（虽然 Java 9 本身不直接提供，但书中会涉及相关的概念和第三方库的应用）或者响应式编程（Reactive Streams API 在 Java 9 中的引入），都处理得非常到位。他不会直接抛出晦涩难懂的术语，而是先从问题的本质入手，解释为什么需要这种新的编程范式，然后通过清晰的代码示例，展示如何使用 Java 9 提供的特性（如 `Flow` API）来实现响应式的并发处理。 我特别喜欢书中关于线程池调优的部分。很多时候，我们只知道使用 `ThreadPoolExecutor`，但对于如何设置核心线程数、最大线程数、线程存活时间、阻塞队列类型等参数，往往感到迷茫。这本书提供了非常实用的指导，它结合了理论分析和性能测试，给出了不同场景下（CPU密集型、I/O密集型）的线程池配置建议，并且解释了每种配置对系统性能的影响。这让我能够根据实际业务需求，更科学地配置线程池，避免资源浪费或性能瓶颈。这种“知其然，更知其所以然”的学习体验，是其他很多书籍难以提供的。

“Java 9 并发编程实战”这本书，我断断续续地读了快一个月了，期间夹杂着工作中的一些紧急项目，所以进度算不上飞快，但每一次翻开它，都能感受到一种踏实的进步。初次接触这本书，我最深的印象是它在基础概念上的讲解非常到位。作者并没有上来就抛出复杂的并发模型，而是从 Java 内存模型这个最根本的部分开始，循序渐进地梳理了线程的创建、生命周期、同步机制（如 `synchronized` 关键字、`Lock` 接口）以及原子性、可见性、有序性这些核心的并发特性。这些概念在很多并发书籍中都会提及，但这本书的讲解方式显得格外清晰，它通过丰富的代码示例，将抽象的概念具象化，让我不再是死记硬背，而是真正理解了为什么需要这些机制，以及它们是如何在底层工作的。 特别值得称赞的是，书中对 `java.util.concurrent` 包的介绍。这部分内容堪称精华，它详细讲解了各种并发工具类，如 `ExecutorService`、`ThreadPoolExecutor`、`Future`、`Callable`，以及各种同步器（`Semaphore`、`CountDownLatch`、`CyclicBarrier`）和集合类（`ConcurrentHashMap`、`BlockingQueue`）。作者不仅给出了这些类的 API 介绍，更重要的是，他通过实际的应用场景，例如构建一个高性能的 Web 服务器、实现一个简单的生产者-消费者模型、或者并发下载文件的例子，生动地展示了如何利用这些工具来解决实际的并发问题。读到这些章节的时候，我经常会停下来，在脑海中模拟代码的执行流程，尝试去思考不同的参数配置会带来什么样的性能影响。这种“动手”式的学习过程，极大地提升了我的理解深度。

“Java 9 并发编程实战”这本书，在技术深度和广度上都做得相当出色。作者在讲解 Java 9 引入的并发新特性时，如 `Flow` API 和响应式流，都处理得非常及时和到位。他不仅介绍了这些新特性的基本用法，更重要的是，他还阐述了它们出现的背景和解决的问题，以及如何将它们与现有的并发工具相结合使用。 我尤其赞赏作者在讲解并发集合类时的细致。他不仅介绍了 `ConcurrentHashMap`、`CopyOnWriteArrayList` 等常用类，还深入分析了它们在不同并发场景下的性能表现和适用性。通过大量的测试数据和图表，他展示了不同集合类在读写密集型、写读密集型等场景下的优劣，这让我能够根据实际需求，选择最合适的并发集合类，从而优化程序的性能。