Java并发编程设计原则与模式（第二版）：第1章概览与核心概念

需积分: 9 66 浏览量更新于2024-07-18 收藏 3.57MB PDF 举报

"《Java并发编程：设计原则与模式（第二版）》是一本专为Java程序员量身打造的书籍，旨在探讨在Java编程语言中进行并发编程的方法、设计思路和实现策略。尽管作者假设读者已经具备了面向对象编程（Object-Oriented Programming，OO）的基本经验，但对于较少接触并发编程的开发者来说，书中的内容同样具有价值。本书共分为四个粗粒度的章节，每个章节都围绕Java语言提供的三种主要并发构造展开深入讨论。第一章“并发面向对象编程”首先简要介绍了一些常用的并发构造，然后逐步建立起并发和对象之间的概念联系。作者强调了并发设计如何影响类和组件的设计，以及如何运用常见的设计模式来组织解决方案。这些设计原则帮助开发者理解和构建稳健的并发系统。接下来的三章分别聚焦于Java编程中的三种核心并发构造：互斥（Exclusion），通过防止多个线程同时访问对象的状态来维护一致性；同步（Synchronization），确保并发访问共享资源的正确执行顺序；以及并发控制（Concurrency Control），管理多线程环境下的任务调度和协作。作者会详细讲解如何在实践中避免常见的并发问题，并提供实例来演示如何有效利用这些机制。这本书不仅适合想要深入学习Java并发编程的专业人士，对于那些希望通过Java探索并发世界的新手，也能提供实用的指导和实践经验。通过阅读这本书，读者将掌握在Java平台上设计和实施高效、可靠且可扩展的并发应用所需的理论基础和实践技巧。"

across platforms. For example, some JVM implementations always select the thread with the

highest current priority (with ties broken arbitrarily). Some JVM implementations map the ten

Thread priorities into a smaller number of system-supported categories, so threads with

different priorities may be treated equally. And some mix declared priorities with aging

schemes or other scheduling policies to ensure that even low-priority threads eventually get a

chance to run. Also, setting priorities may, but need not, affect scheduling with respect to

other programs running on the same computer system.

Priorities have no other bearing on semantics or correctness (see § 1.3). In particular, priority

manipulations cannot be used as a substitute for locking. Priorities can be used only to

express the relative importance or urgency of different threads, where these priority

indications would be useful to take into account when there is heavy contention among

threads trying to get a chance to execute. For example, setting the priorities of the particle

animation threads in ParticleApplet below that of the applet thread constructing them

might on some systems improve responsiveness to mouse clicks, and would at least not hurt

responsiveness on others. But programs should be designed to run correctly (although

perhaps not as responsively) even if setPriority is defined as a no-op. (Similar remarks

hold for yield; see § 1.1.2.5.)

The following table gives one set of general conventions for linking task categories to priority

settings. In many concurrent applications, relatively few threads are actually runnable at any

given time (others are all blocked in some way), in which case there is little reason to

manipulate priorities. In other cases, minor tweaks in priority settings may play a small part in

the final tuning of a concurrent system.

Range Use

10 Crisis management

7-9 Interactive, event-driven

4-6 IO-bound

2-3 Background computation

1 Run only if nothing else can

1.1.2.4 Control methods

Only a few methods are available for communicating across threads:

Each Thread has an associated boolean interruption status (see § 3.1.2). Invoking

t.interrupt for some Thread t sets t's interruption status to true, unless

Thread t is engaged in Object.wait, Thread.sleep, or Thread.join; in

this case interrupt causes these actions (in t) to throw

InterruptedException, but t's interruption status is set to false.

The interruption status of any Thread can be inspected using method

isInterrupted. This method returns true if the thread has been interrupted via

the interrupt method but the status has not since been reset either by the thread

invoking Thread.interrupted (see § 1.1.2.5) or in the course of wait, sleep,

or join throwing InterruptedException.

Invoking t.join() for Thread t suspends the caller until the target Thread t

completes: the call to t.join() returns when t.isAlive() is false (see §

4.3.2). A version with a (millisecond) time argument returns control even if the thread has

not completed within the specified time limit. Because of how isAlive is defined, it

makes no sense to invoke join on a thread that has not been started. For similar

reasons, it is unwise to try to join a Thread that you did not create.

Originally, class Thread supported the additional control methods suspend, resume,

stop, and destroy. Methods suspend, resume, and stop have since been

deprecated; method destroy has never been implemented in any release and probably

never will be. The effects of methods suspend and resume can be obtained more safely

and reliably using the waiting and notification techniques discussed in § 3.2. The problems

surrounding stop are discussed in § 3.1.2.3.

1.1.2.5 Static methods

Some Thread class methods can be applied only to the thread that is currently running (i.e.,

the thread making the call to the Thread method). To enforce this, these methods are

declared as static.

Thread.currentThread returns a reference to the current Thread. This

reference may then be used to invoke other (non-static) methods. For example,

Thread.currentThread().getPriority() returns the priority of the thread

making the call.

Thread.interrupted clears interruption status of the current Thread and returns

previous status. (Thus, one Thread's interruption status cannot be cleared from other

threads.)

Thread.sleep(long msecs) causes the current thread to suspend for at least

msecs milliseconds (see § 3.2.2).

Thread.yield is a purely heuristic hint advising the JVM that if there are any other

runnable but non-running threads, the scheduler should run one or more of these

threads rather than the current thread. The JVM may interpret this hint in any way it

likes.

Despite the lack of guarantees, yield can be pragmatically effective on some single-CPU

JVM implementations that do not use time-sliced pre-emptive scheduling (see § 1.2.2). In this

case, threads are rescheduled only when one blocks (for example on IO, or via sleep). On

these systems, threads that perform time-consuming non-blocking computations can tie up a

CPU for extended periods, decreasing the responsiveness of an application. As a safeguard,

methods performing non-blocking computations that might exceed acceptable response times

for event handlers or other reactive threads can insert yields (or perhaps even sleeps)

and, when desirable, also run at lower priority settings. To minimize unnecessary impact, you

can arrange to invoke yield only occasionally; for example, a loop might contain:

if (Math.random() < 0.01) Thread.yield();

On JVM implementations that employ pre-emptive scheduling policies, especially those on

multiprocessors, it is possible and even desirable that the scheduler will simply ignore this hint

provided by yield.

1.1.2.6 ThreadGroups

Every Thread is constructed as a member of a ThreadGroup, by default the same group

as that of the Thread issuing the constructor for it. ThreadGroups nest in a tree-like

fashion. When an object constructs a new ThreadGroup, it is nested under its current

group. The method getThreadGroup returns the group of any thread. The

ThreadGroup class in turn supports methods such as enumerate that indicate which

threads are currently in the group.

One purpose of class ThreadGroup is to support security policies that dynamically restrict

access to Thread operations; for example, to make it illegal to interrupt a thread that is

not in your group. This is one part of a set of protective measures against problems that could

occur, for example, if an applet were to try to kill the main screen display update thread.

ThreadGroups may also place a ceiling on the maximum priority that any member thread

can possess.

ThreadGroups tend not to be used directly in thread-based programs. In most

applications, normal collection classes (for example java.util.Vector) are better

choices for tracking groups of Thread objects for application-dependent purposes.

Among the few ThreadGroup methods that commonly come into play in concurrent

programs is method uncaughtException, which is invoked when a thread in a group

terminates due to an uncaught unchecked exception (for example a

NullPointerException). This method normally causes a stack trace to be printed.

1.1.3 Further Readings

This book is not a reference manual on the Java programming language. (It is also not

exclusively a how-to tutorial guide, or an academic textbook on concurrency, or a report on

experimental research, or a book on design methodology or design patterns or pattern

languages, but includes discussions on each of these facets of concurrency.) Most sections

conclude with lists of resources that provide more information on selected topics. If you do a

lot of concurrent programming, you will want to read more about some of them.

1.2 Objects and Concurrency

There are many ways to characterize objects, concurrency, and their relationships. This

section discusses several different perspectives — definitional, system-based, stylistic, and

modeling-based — that together help establish a conceptual basis for concurrent object-

oriented programming.

1.2.1 Concurrency

Like most computing terms, "concurrency" is tricky to pin down. Informally, a concurrent

program is one that does more than one thing at a time. For example, a web browser may

be simultaneously performing an HTTP GET request to get an HTML page, playing an audio

clip, displaying the number of bytes received of some image, and engaging in an advisory

dialog with a user. However, this simultaneity is sometimes an illusion. On some computer

systems these different activities might indeed be performed by different CPUs. But on other

systems they are all performed by a single time-shared CPU that switches among different

activities quickly enough that they appear to be simultaneous, or at least nondeterministically

interleaved, to human observers.

A more precise, though not very interesting definition of concurrent programming can be

phrased operationally: A Java virtual machine and its underlying operating system (OS)

provide mappings from apparent simultaneity to physical parallelism (via multiple CPUs), or

lack thereof, by allowing independent activities to proceed in parallel when possible and

desirable, and otherwise by time-sharing. Concurrent programming consists of using

programming constructs that are mapped in this way. Concurrent programming in the

Java programming language entails using Java programming language constructs to this

effect, as opposed to system-level constructs that are used to create new operating system

processes. By convention, this notion is further restricted to constructs affecting a single

JVM, as opposed to distributed programming, for example using remote method invocation

(RMI), that involves multiple JVMs residing on multiple computer systems.

Concurrency and the reasons for employing it are better captured by considering the nature

of a few common types of concurrent applications:

Web services. Most socket-based web services (for example, HTTP daemons, servlet

engines, and application servers) are multithreaded. Usually, the main motivation for

supporting multiple concurrent connections is to ensure that new incoming connections do

not need to wait out completion of others. This generally minimizes service latencies and

improves availability.

Number crunching. Many computation-intensive tasks can be parallelized, and thus execute

more quickly if multiple CPUs are present. Here the goal is to maximize throughput by

exploiting parallelism.

I/O processing. Even on a nominally sequential computer, devices that perform reads and

剩余364页未读，继续阅读

水猴007

粉丝: 36
资源: 6

Java并发编程设计原则与模式（第二版）：第1章概览与核心概念

模拟多线程的Concurrent.Thread.js使用指南

掌握JavaScript多线程：Concurrent.Thread库解析

Python.concurrent.futures模块详解与使用示例

Concurrent+Programming+in+Java+-+Design+Principles+and+Patterns,+Second+Edition_

Concurrent Programming in Java™: Design Principles and Patterns, Second Edition

Prentice.Hall.Filthy.Rich.Clients.Aug.2007.pdf

一本经典的多线程书籍 Java并发编程 设计原则与模式 第二版 (英文原版)

Java并发编程实战：设计原则与模式

Java并发编程设计指南：Doug Lea的实战原则与模式

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

最新资源

一本经典的多线程书籍 Java并发编程设计原则与模式第二版 (英文原版)