JVM上的并发编程实战

5星 · 超过95%的资源需积分: 10 78 浏览量更新于2024-07-30 1 收藏 3.28MB PDF 举报

"Programming Concurrency on the JVM" 《Programming Concurrency on the JVM》是一本深入探讨在Java虚拟机（JVM）上进行并发编程的专著。作者Venkat以其易懂的写作风格和丰富的实例，引领读者理解并掌握多线程编程中的设计和实现决策。这本书特别关注了在JVM平台上开发人员所面临的并发挑战，并提供了多种开源工具和JVM语言的实际应用示例，使得复杂的并发主题变得易于理解。并发编程是现代软件开发中的关键技能，尤其是在JVM平台上，因为其广泛的应用场景和高性能需求。本书深入剖析了JVM的并发机制，包括线程管理、同步机制、内存模型以及并发库的使用，如Java的并发工具类（java.util.concurrent）和Java内存模型（JMM）等。作者Albert Scherer强调，这本书对于选择JVM作为平台的开发者来说是必不可少的阅读材料。他建议团队成员都应阅读，以便更好地解决并发问题。Raju Gandhi，一位资深咨询顾问，也推荐本书，认为它能帮助团队找到并发问题的良好解决方案。 Chris Richardson，POJOs in Action一书的作者和CloudFoundry.com的创始人，称赞本书对一个关键主题进行了极其详尽的覆盖。他指出，随着新的并发模型和JVM语言的爆发式增长，Venkat的书将所有这些联系起来，教导开发者如何构建他们的应用程序，充分利用现有的库来实现最大的性能提升。书中可能涵盖了以下核心知识点： 1. **线程与进程**：解释了线程与进程的基本概念，以及在JVM中创建和管理线程的方式。 2. **同步机制**：包括synchronized关键字、Lock接口、ReentrantLock、Semaphore、CountDownLatch、CyclicBarrier等同步工具的使用。 3. **并发工具类**：详细介绍了java.util.concurrent包中的并发工具类，如Executor框架、Future、Callable等。 4. **原子变量与并发容器**：如AtomicInteger、AtomicLong等原子变量的使用，以及ConcurrentHashMap、CopyOnWriteArrayList等并发容器的特性。 5. **线程安全**：讨论了线程安全的实现策略，如Immutable对象、ThreadLocal、Double-Check Locking等。 6. **Java内存模型**：深入解析JMM，包括可见性、有序性和volatile关键字的作用。 7. **并发编程模式**：如生产者消费者模式、工作窃取算法、线程池的设计等。 8. **JVM内存模型**：探讨堆、栈、方法区、元空间等JVM内存区域在并发环境下的行为。 9. **并行流与并发集合**：Java 8引入的并行流和并发集合（如ParallelStream和ForkJoinPool）如何提升并发性能。 10. **JVM优化**：分析如何通过调整JVM参数来优化并发程序的性能。通过对这些知识点的详细讲解，本书旨在帮助读者不仅理解并发编程的理论，还能在实践中有效地利用这些知识来解决实际问题，提高JVM应用的并发性能和可伸缩性。无论是初级开发者还是经验丰富的专家，都能从这本书中获益匪浅。

In the listing of code examples, I haven’t shown the import statements (and

the package statements) because these often become lengthy. When trying

the code examples, if you’re not sure which package a class belongs to, don’t

worry, I’ve included the full listing on the code website. Go ahead and

download the entire source code for this book from its website (

http://pragprog.

com/titles/vspcon

Acknowledgments

Several people concurrently helped me to write this book. If not for the

generosity and inspiration from some of the great minds I’ve come to know

and respect over the years, this book would have remained a great idea in

my mind.

I first thank the reviewers who braved to read the draft of this book and

who offered valuable feedback—this is a better book because of them.

However, any errors you find in this book are entirely a reflection of my de-

ficiencies.

I benefited a great deal from the reviews and shrewd remarks of Brian Goetz

(@B ri a nG oet z) , A le x Mi ll er (@p ure da n ge r), a nd Jo n as Bo n ér ( @jb on e r) . A lm ost

every page in the book was improved by the thorough review and eagle eyes

of Al Scherer (@al_scherer) and Scott Leberknight (@sleberknight). Thank

you very much, gentlemen.

Special thanks go to Raju Gandhi (@looselytyped), Ramamurthy Gopalakr-

ishnan, Paul King (@paulk_asert), Kurt Landrus (@koctya), Ted Neward

(@tedneward), Chris Richardson (@crichardson), Andreas Rueger, Nathaniel

Schutta (@ntschutta), Ken Sipe (@kensipe), and Matt Stine (@mstine) for

devoting your valuable time to correct me and encourage me at the same

time. Thanks to Stuart Halloway (@stuarthalloway) for his cautionary review.

I’ve improved this book, where possible, based on his comments.

The privilege to speak on this topic at various NFJS conferences helped

shape the content of this book. I thank the NFJS (@nofluff) director Jay

Zimmerman for that opportunity and my friends on the conference circuit

both among speakers and attendees for their conversations and discussions.

I thank the developers who took the time to read the book in the beta form

and offer their feedback on the book’s forum. Thanks in particular to Dave

Briccetti (@dcbriccetti), Frederik De Bleser (@enigmeta), Andrei Dolganov,

Rabea Gransberger, Alex Gout, Simon Sparks, Brian Tarbox, Michael Uren,

Dale Visser, and Tasos Zervos. I greatly benefited from the insightful com-

ments, corrections, and observations of Rabea Gransberger.

xvi • Preface

report erratum • discuss

When multiple threads run as part of a single application, or a JVM, we

have multiple tasks or operations running concurrently. A concurrent appli-

cation makes use of multiple threads or concurrent flows of execution.

On a single processor, these concurrent tasks are often multiplexed or

multitasked. That is, the processor rapidly switches between the context of

each flow of execution. However, only one thread, and hence only one flow

of execution, is performed at any given instance. On a multicore processor,

more than one flow of execution (thread) is performed at any given instance.

That number depends on the number of cores available on the processor,

and the number of concurrent threads for an application depends on the

number of cores associated with its process.

1.2 The Power of Concurrency

We’re interested in concurrency for two reasons: to make an application

responsive/improve the user experience and to make it faster.

Making Apps More Responsive

When we start an application, the main thread of execution often takes on

multiple responsibilities sequentially, depending on the actions we ask it to

perform: receive input from a user, read from a file, perform some calcula-

tions, access a web service, update a database, display a response to the

user, and so on. If each of these operations takes only fractions of a second,

then there may be no real need to introduce additional flows of execution;

a single thread may be quite adequate to meet the needs.

In most nontrivial applications, however, these operations may not be that

quick. Calculations may take anywhere from a couple of seconds to a few

minutes. Requests for data from that web service may encounter network

dela y s, so the th read waits fo r t h e r espon se t o a rriv e . W hile this is h a ppen i ng,

there’s no way for the users of the application to interact with or interrupt

the application because the single thread is held on some operation to finish.

Let’s consider an example that illustrates the need for more than one thread

and how it impacts responsiveness. We often time events, so it would be

nice to have stopwatch application. We can click a button to start the watch,

and it will run until we click the button again. A naively written

bit of code

for this is shown next (only the action handler for the button is shown; you

can download the full program from the website for this book):

1. In the examples, we’ll simply let exceptions propagate instead of logging or handling

them—but be sure to handle exceptions properly in your production code.

2 • Chapter 1. The Power and Perils of Concurrency

report erratum • discuss

剩余281页未读，继续阅读

birdd001

粉丝: 1
资源: 13

JVM上的并发编程实战

Programming Concurrency on the JVM 无水印pdf

Programming.Concurrency.on.the.JVM

Clojure.High.Performance.JVM.Programming.epub

Programming Scala

Functional Programming pdf 2018

Learning Concurrent Programming in Scala, 2nd Edition

Clojure High Performance Programming(PACKT,2ed,2015)

scala for the impatient

JVM并发编程实战

JVM多线程编程实践指南

最新资源