Java并发编程实践解析

需积分: 5 151 浏览量更新于2024-08-02 1 收藏 3.65MB PDF 举报

"Java Concurrency in Practice" 是一本关于Java多线程编程实践的专业书籍，由Brian Goetz、Tim Peierls、Joshua Bloch、Joseph Bowbeer、David Holmes和Doug Lea等专家共同撰写。这本书是PDF格式，并且带有作者在阅读过程中添加的英语单词注解，方便英文阅读能力较弱的读者理解。该书于2006年由Addison Wesley Professional出版社出版，共384页，包含详细的目录和索引。本书是针对Java 5.0和Java 6平台新增并发特性的权威解释，这些特性使得并发编程对所有Java开发者来说都变得至关重要。Martin Buchholz，作为JDK并发 czar（负责人）和Sun Microsystems的成员，高度推荐这本书，认为每个Java开发者都应该阅读，因为它不仅适用于高级用户，也适合初学者。随着计算机性能的发展，从摩尔定律向阿姆达尔定律转变，有效利用多处理器的能力成为了一个重要的挑战。"Java Concurrency in Practice" 提供了关于并发编程的概念和技巧，帮助开发者编写能够高效利用多核处理器的代码。书中涵盖了以下几个主要知识点： 1. **线程安全**：书中详细讨论了如何确保代码在多线程环境下正确无误地执行，包括线程安全的类和方法，以及如何避免竞态条件、死锁和活锁等问题。 2. **同步机制**：介绍了synchronized关键字、volatile变量、java.util.concurrent包中的高级同步工具，如Semaphore、Lock、ReadWriteLock等，以及它们的适用场景和使用策略。 3. **并发设计模式**：书中介绍了如生产者消费者模型、工作窃取、线程池等并发设计模式，帮助开发者构建可扩展和高效的并发程序。 4. **线程局部变量**：讲解了ThreadLocal类的使用，它允许每个线程拥有自己的变量副本，避免了共享状态带来的问题。 5. **并发集合**：详细阐述了java.util.concurrent包中的并发集合，如ConcurrentHashMap、CopyOnWriteArrayList等，这些集合提供了线程安全的访问方式，优化了并发性能。 6. **性能优化**：讨论了如何评估和优化并发代码的性能，以及如何利用并行化来提高程序的运行效率。 7. **异常处理**：在并发环境中，异常处理显得尤为重要，书中指导如何正确处理线程间的异常，以防止程序的不稳定性。 8. **线程池管理**：解释了Executor框架的使用，以及如何配置和管理线程池以达到最佳性能。 9. **并发工具和API**：全面解析了java.util.concurrent包中的各种工具类和API，如Future、CountDownLatch、CyclicBarrier、Phaser等，这些都是编写并发程序的重要工具。通过学习这本书，读者可以深入理解Java并发编程的核心概念，掌握在实际开发中编写高性能、高并发应用的技能。无论你是初涉并发的开发者，还是有经验的并发编程者，都能从中受益匪浅。

16.4

Thread-safe lazy initialization

347

16.5

Eager initialization

347

16.6

Lazy initialization holder class idiom

348

16.7

Double-checked-locking antipattern. Don't do this.

349

16.8

Initialization safety for immutable objects

350

Preface

At this writing, multicore processors are just now becoming inexpensive enough for midrange

desktop systems. Not coincidentally, many development teams are noticing more and more

threading-related bug reports in their projects. In a recent post on the NetBeans developer site,

one of the core maintainers observed that a single class had been patched over 14 times to fix

threading-related problems. Dion Almaer, former editor of TheServerSide, recently blogged (after

a painful debugging session that ultimately revealed a threading bug) that most Java programs

are so rife with concurrency bugs that they work only "by accident".

Indeed, developing, testing and debugging multithreaded programs can be extremely difficult

because concurrency bugs do not manifest themselves predictably. And when they do surface, it

is often at the worst possible timein production, under heavy load.

One of the challenges of developing concurrent programs in Java is the mismatch between the

concurrency features offered by the platform and how developers need to think about

concurrency in their programs. The language provides low-level mechanisms such as

synchronization and condition waits, but these mechanisms must be used consistently to

implement application-level protocols or policies. Without such policies, it is all too easy to create

programs that compile and appear to work but are nevertheless broken. Many otherwise excellent

books on concurrency fall short of their goal by focusing excessively on low-level mechanisms and

APIs rather than design-level policies and patterns.

Java 5.0 is a huge step forward for the development of concurrent applications in Java, providing

new higher-level components and additional low-level mechanisms that make it easier for novices

and experts alike to build concurrent applications. The authors are the primary members of the

JCP Expert Group that created these facilities; in addition to describing their behavior and

features, we present the underlying design patterns and anticipated usage scenarios that

motivated their inclusion in the platform libraries.

Our goal is to give readers a set of design rules and mental models that make it easierand more

funto build correct, performant concurrent classes and applications in Java.

We hope you enjoy Java Concurrency in Practice.

Brian Goetz

Williston, VT

March 2006

How to Use this Book

To address the abstraction mismatch between Java's low-level mechanisms and the necessary

design-level policies, we present a simplified set of rules for writing concurrent programs. Experts

may look at these rules and say "Hmm, that's not entirely true: class C is thread-safe even

though it violates rule R." While it is possible to write correct programs that break our rules, doing

so requires a deep understanding of the low-level details of the Java Memory Model, and we want

developers to be able to write correct concurrent programs without having to master these

details. Consistently following our simplified rules will produce correct and maintainable

concurrent programs.

n.适中范围

not coincidentally 与此同时

adj.流行的，普遍的

ad.否则，除此之外

alike ad.一样地，同样地

We assume the reader already has some familiarity with the basic mechanisms for concurrency in

Java. Java Concurrency in Practice is not an introduction to concurrencyfor that, see the threading

chapter of any decent introductory volume, such as The Java Programming Language (Arnold et

al., 2005). Nor is it an encyclopedic reference for All Things Concurrencyfor that, see Concurrent

Programming in Java (Lea, 2000). Rather, it offers practical design rules to assist developers in

the difficult process of creating safe and performant concurrent classes. Where appropriate, we

cross-reference relevant sections of The Java Programming Language, Concurrent Programming

in Java, The Java Language Specification (Gosling et al., 2005), and Effective Java (Bloch, 2001)

using the conventions [JPL n.m], [CPJ n.m], [JLS n.m], and [EJ Item n].

After the introduction (Chapter 1), the book is divided into four parts:

Fundamentals. Part I (Chapters 2-5) focuses on the basic concepts of concurrency and thread

safety, and how to compose thread-safe classes out of the concurrent building blocks provided by

the class library. A "cheat sheet" summarizing the most important of the rules presented in Part I

appears on page 110.

Chapters 2 (Thread Safety) and 3 (Sharing Objects) form the foundation for the book. Nearly all

of the rules on avoiding concurrency hazards, constructing thread-safe classes, and verifying

thread safety are here. Readers who prefer "practice" to "theory" may be tempted to skip ahead

to Part II, but make sure to come back and read Chapters 2 and 3 before writing any concurrent

code!

Chapter 4 (Composing Objects) covers techniques for composing thread-safe classes into larger

thread-safe classes. Chapter 5 (Building Blocks) covers the concurrent building blocksthread-safe

collections and synchronizersprovided by the platform libraries.

Structuring Concurrent Applications. Part II (Chapters 6-9) describes how to exploit threads

to improve the throughput or responsiveness of concurrent applications. Chapter 6 (Task

Execution) covers identifying parallelizable tasks and executing them within the task-execution

framework. Chapter 7 (Cancellation and Shutdown) deals with techniques for convincing tasks

and threads to terminate before they would normally do so; how programs deal with cancellation

and shutdown is often one of the factors that separates truly robust concurrent applications from

those that merely work. Chapter 8 (Applying Thread Pools) addresses some of the more advanced

features of the task-execution framework.

Chapter 9 (GUI Applications) focuses on techniques for improving responsiveness in single-

threaded subsystems.

Liveness, Performance, and Testing. Part III (Chapters 10-12) concerns itself with ensuring

that concurrent programs actually do what you want them to do and do so with acceptable

performance. Chapter 10 (Avoiding Liveness Hazards) describes how to avoid liveness failures

that can prevent programs from making forward progress. Chapter 11 (Performance and

Scalability) covers techniques for improving the performance and scalability of concurrent code.

Chapter 12 (Testing Concurrent Programs) covers techniques for testing concurrent code for both

correctness and performance.

Advanced Topics. Part IV (Chapters 13-16) covers topics that are likely to be of interest only to

experienced developers: explicit locks, atomic variables, nonblocking algorithms, and developing

custom synchronizers.

Code Examples

While many of the general concepts in this book are applicable to versions of Java prior to Java

hazard n.危险，公害

parallelizable adj.可平行化的

responsiveness n.响应能力

liveness n.生动，活跃度

5.0 and even to non-Java environments, most of the code examples (and all the statements

about the Java Memory Model) assume Java 5.0 or later. Some of the code examples may use

library features added in Java 6.

The code examples have been compressed to reduce their size and to highlight the relevant

portions. The full versions of the code examples, as well as supplementary examples and errata,

are available from the book's website, http://www.javaconcurrencyinpractice.com.

The code examples are of three sorts: "good" examples, "not so good" examples, and "bad"

examples. Good examples illustrate techniques that should be emulated. Bad examples illustrate

techniques that should definitely not be emulated, and are identified with a "Mr. Yuk" icon

[1]

make it clear that this is "toxic" code (see Listing 1). Not-so-good examples illustrate techniques

that are not necessarily wrong but are fragile, risky, or perform poorly, and are decorated with a

"Mr. Could BeHappier" icon as in Listing 2.

[1]

Mr. Yuk is a registered trademark of the Children's Hospital of Pittsburgh and appears by permission.

Listing 1. Bad Way to Sort a List. Don't Do this.

public <T extends Comparable<? super T>> void sort(List<T> list) {

// Never returns the wrong answer!

System.exit(0);

}

Some readers may question the role of the "bad" examples in this book; after all, a book should

show how to do things right, not wrong. The bad examples have two purposes. They illustrate

common pitfalls, but more importantly they demonstrate how to analyze a program for thread

safetyand the best way to do that is to see the ways in which thread safety is compromised.

Listing 2. Less than Optimal Way to Sort a List.

public <T extends Comparable<? super T>> void sort(List<T> list) {

for (int i=0; i<1000000; i++)

doNothing();

Collections.sort(list);

}

Acknowledgments

This book grew out of the development process for the java.util.concurrent package that was

supplementary adj.增补的，补充的

n.勘误表

emulate v.效仿，模仿

toxic adj.有毒的

fragile adj.易碎的，脆弱的

decorate v.装饰，装潢

commpromise vt.危机，放弃（原则等）

optimal adj.最佳的，最理想的

始于，源于

created by the Java Community Process JSR 166 for inclusion in Java 5.0. Many others

contributed to JSR 166; in particular we thank Martin Buchholz for doing all the work related to

getting the code into the JDK, and all the readers of the concurrency-interest mailing list who

offered their suggestions and feedback on the draft APIs.

This book has been tremendously improved by the suggestions and assistance of a small army of

reviewers, advisors, cheerleaders, and armchair critics. We would like to thank Dion Almaer,

Tracy Bialik, Cindy Bloch, Martin Buchholz, Paul Christmann, Cliff Click, Stuart Halloway, David

Hovemeyer, Jason Hunter, Michael Hunter, Jeremy Hylton, Heinz Kabutz, Robert Kuhar, Ramnivas

Laddad, Jared Levy, Nicole Lewis, Victor Luchangco, Jeremy Manson, Paul Martin, Berna

Massingill, Michael Maurer, Ted Neward, Kirk Pepperdine, Bill Pugh, Sam Pullara, Russ Rufer, Bill

Scherer, Jeffrey Siegal, Bruce Tate, Gil Tene, Paul Tyma, and members of the Silicon Valley

Patterns Group who, through many interesting technical conversations, offered guidance and

made suggestions that helped make this book better.

We are especially grateful to Cliff Biffle, Barry Hayes, Dawid Kurzyniec, Angelika Langer, Doron

Rajwan, and Bill Venners, who reviewed the entire manuscript in excruciating detail, found bugs in

the code examples, and suggested numerous improvements.

We thank Katrina Avery for a great copy-editing job and Rosemary Simpson for producing the

index under unreasonable time pressure. We thank Ami Dewar for doing the illustrations.

Thanks to the whole team at Addison-Wesley who helped make this book a reality. Ann Sellers

got the project launched and Greg Doench shepherded it to a smooth completion; Elizabeth Ryan

guided it through the production process.

We would also like to thank the thousands of software engineers who contributed indirectly by

creating the software used to create this book, including TEX, LATEX, Adobe Acrobat, pic, grap,

Adobe Illustrator, Perl, Apache Ant, IntelliJ IDEA, GNU emacs, Subversion, TortoiseSVN, and of

course, the Java platform and class libraries.

剩余472页未读，继续阅读

sunmellon

粉丝: 10
资源: 4

Java并发编程实践解析

Java Concurrency in Practice 无水印pdf

java concurrency in practice 下载

请列出所有对于初学java的书籍

可以推荐几本中文java书籍吗？

javaconcurrencyinpractice

Java企业开发相关技术的书籍

java 外文参考文献_java英文参考文献

近3年的Java参考文献

java 技术相关书籍推荐

2021年至2023年出版的Java类书籍

最新资源