JVM多线程编程实践指南

需积分: 10 116 浏览量更新于2024-07-29 收藏 3.91MB PDF 举报

"Programming Concurrency On JVM.pdf 是一本2011年的书籍，专注于在Java虚拟机（JVM）上进行并发编程的实践与设计。读者赞誉这本书为深入浅出地探讨多线程编程的优秀读物，作者Venkat通过各种开源工具和JVM语言的实例，使这个复杂的主题变得易于理解。它对于选择JVM作为平台的开发者来说是必读之作，对并发问题的解决提供了有力指导，并涵盖了关键的并发编程话题。" 在《Programming Concurrency On JVM》这本书中，作者探讨了JVM上的并发编程所面临的各种设计和实现决策。并发编程是现代软件开发中的一个核心领域，尤其是在JVM平台上，由于其多线程支持和高性能特性，使得并发处理成为提升系统性能的关键手段。 1. **并发基础知识**：书中可能涵盖了基础的并发概念，如线程、进程、同步、互斥、死锁、活锁和饥饿等，这些都是理解和解决并发问题的基础。 2. **Java并发API**：可能会详细介绍Java提供的并发工具，如`java.util.concurrent`包中的线程池、Future、Callable、ExecutorService以及同步容器和并发集合等。 3. **并发模式**：书中可能讨论了各种经典的并发模式，如生产者-消费者模型、读写锁策略、双检查锁定、线程安全的单例模式等，这些都是解决并发问题的有效方法。 4. **JVM内存模型**：书中可能深入讲解了JVM内存模型和Java内存模型（JMM），包括可见性、有序性和原子性，这些都是理解并发行为的关键。 5. **并发语言与工具体验**：根据描述，书中使用了多种JVM语言（如Groovy、Scala、Clojure等）和开源工具来举例，这为读者提供了不同视角来看待并发编程，同时也展示了如何在不同语言环境下实现并发。 6. **性能优化**：书中可能包含如何有效地利用多核处理器，提高并发程序的性能，以及如何避免或减少上下文切换和竞态条件等。 7. **实战案例分析**：通过实际案例，作者可能展示了如何在实际项目中应用并发编程技巧，以及如何调试和诊断并发问题。 8. **错误与异常处理**：在并发环境中，错误和异常的处理尤为重要，书中的例子可能教导读者如何优雅地处理这些问题。 9. **并发设计原则**：书中可能强调了在并发编程中应遵循的设计原则，如最小化共享状态、使用不可变对象、避免阻塞等。 10. **未来趋势与新技术**：考虑到书籍出版于2011年，它可能还讨论了当时的新并发模型和JVM语言的发展，比如反应式编程和Akka框架等。《Programming Concurrency On 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

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

剩余281页未读，继续阅读

cxzav

粉丝: 4

JVM多线程编程实践指南

Programming Concurrency on the JVM 无水印pdf

Programming Concurrency on the JVM

Clojure.High.Performance.JVM.Programming.epub

concurrency in action, 2nd edition.pdf

guava.concurrency.level=20

qt开发进阶教程 .pdf

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

关于Java的外文期刊参考文献

java等待唤醒机制

最新资源