深入理解Java多线程：效率与安全性探索

需积分: 12 144 浏览量更新于2024-07-27 1 收藏 1.26MB PDF 举报

"Java Threads, 2Ed (英文版）是一本深入探讨Java多线程编程的经典书籍，由Scott Oaks和Henry Wong合著，第二版涵盖了Java 2平台的最新特性。本书旨在帮助开发者充分理解和有效地利用Java的线程机制，避免在编程过程中遇到的常见错误。" 在Java编程中，线程是实现并发执行的关键组件，对于提高程序效率至关重要。本书详细讲解了如何在适当的情况下使用线程来提升性能，以及如何有效地管理和控制线程的行为。作者不仅介绍了`Thread`类和`ThreadGroup`类，还讨论了`Runnable`接口，这是创建和管理线程的两种主要方式。通过理解这些基础知识，开发者可以更好地设计和实现并发应用程序。书中特别关注了Swing组件中的线程问题，因为Swing不是线程安全的，不正确的线程操作可能导致界面的不稳定或数据的不一致。此外，作者还详细分析了可能导致问题的并发问题，如死锁、竞态条件和饥饿现象，这些都是多线程编程中常见的陷阱。通过具体的示例，读者可以学习如何编写无隐藏bug的代码，确保程序的健壮性。书中的章节结构清晰，包括： 1. 引言部分介绍了线程的基本概念，定义了一些关键的Java术语，并概述了为什么我们需要使用线程。 2. 第二章详细讲述了使用`Thread`类进行线程编程，以及通过实现`Runnable`接口来创建线程的方法，还涵盖了线程的生命周期、命名、访问控制和启动、停止与join操作。 3. 第三章深入讲解了同步技术，通过银行转账的例子展示了同步的必要性，演示了异步数据读取、同步类、同步块、嵌套锁以及如何避免死锁，并对静态方法的同步进行了讨论。这本Java Threads, 2Ed提供了丰富的实践案例和深入的理论解析，是Java开发者提升多线程编程能力的必备参考资料。无论你是初学者还是经验丰富的开发者，都能从中受益，掌握在Java环境中构建高效并发程序的技巧。

Java Threads, 2nd edition

age 11

The complete answer to the question "Why threads?" really lies in this category. As programmers,

we're trained to think linearly and often fail to see simultaneous paths that our program might take.

But there's no reason why processes that we've conventionally thought of in a single-threaded fashion

need necessarily remain so: when the Save button in a word processor is pressed, we typically have to

wait a few seconds until we can continue. Worse yet, the word processor may periodically perform an

autosave, which invariably interrupts the flow of typing and disrupts the thought process. In a

threaded word processor, the save operation would be in a separate thread so that it didn't interfere

with the work flow. As you become accustomed to writing programs with multiple threads, you'll

discover many circumstances in which adding a separate thread will make your algorithms more

elegant and your programs better to use.

1.3.4 Parallelizable Algorithms

With the advent of virtual machines that can use multiple CPUs simultaneously, Java has become a

useful platform for developing programs that use algorithms that can be parallelized. Any program

that contains a loop is a candidate for being parallelized; that is, running one iteration of the loop on

one CPU while another iteration of the loop is simultaneously running on another CPU. Dependencies

between the data that each iteration of the loop needs may prohibit a particular loop from being

parallelized, and there may be other reasons why a loop should not be parallelized. But for many

programs with CPU-intensive loops, parallelizing the loop will greatly speed up the execution of the

program when it is run on a machine with multiple processors.

Many languages have compilers that support automatic parallelization of loops; as yet, Java does not.

But as we'll see in Chapter 9, parallelizing a loop by hand is often not a difficult task.

1.4 Summary

The idea of multiple threads of control within a single program may seem like a new and difficult

concept, but it is not. All programs have at least one thread already, and multiple threads in a single

program are not radically different from multiple programs within an operating system.

A Java program can contain many threads, all of which may be created without the explicit knowledge

of the developer. For now, all you need to consider is that when you write a Java application, there is

an initial thread that begins its operation by executing the

main() method of your application. When

you write a Java applet, there is a thread that is executing the callback methods (

init(),

actionPerformed(), etc.) of your applet; we speak of this thread as the applet's thread. In either case,

your program starts with what you can consider as a single thread. If you want to perform I/O

(particularly if the I/O might block), start a timer, or do any other task in parallel with the initial

thread, you must start a new thread to perform that task. In the next chapter, we'll examine how to do

just that.

Java Threads, 2nd edition

age 13

What if we want the run() method of OurClass to execute in parallel with the init() and other

methods of the applet? In order to do that, we must modify the OurClass class so that it can be

executed by a new thread. So the first thing we'll do is make OurClass inherit from the Thread

(

java.lang.Thread) class:

public class OurClass extends Thread {

public void run() {

for (int I = 0; I < 100; I++) {

System.out.println("Hello");

}

If we compile this code and run it with our applet, everything works exactly as before: the applet's

init() method calls the run() method of the OurClass object and waits for the run() method to

return before continuing. The fact that this example compiles and runs proves that the Thread class

exists. This class is our first look into the Java threading API and is the programmatic interface for

starting and stopping our own threads. But we have not yet created a new thread of control; we have

simply created a class that has a

run() method. To continue, let's modify our applet like this:

import java.applet.Applet;

public class OurApplet extends Applet {

public void init() {

OurClass oc = new OurClass();

oc.start();

}

In this second version of our applet, we have changed only one line: the call to the run() method is

now a call to the

start() method. Compiling and executing this code confirms that it still works and

appears to the user to run exactly the same way as the previous example. Since the

start() method is

not part of the OurClass class, we can conclude that the implementation of the

start() method is part

of either the Thread class or one of its superclasses. Furthermore, since the applet still accomplishes

the same task, we can conclude that the

start() method causes a call, whether directly or indirectly,

to the

run() method.

Upon closer examination, this new applet actually behaves differently than the previous version.

While it is true that the

start() method eventually calls the run() method, it does so in another

thread. The

start() method is what actually creates another thread of control; this new thread, after

dealing with some initialization details, then calls the

run() method. After the run() method

completes, this new thread also deals with the details of terminating the thread. The

start() method

of the original thread returns immediately. Thus, the

run() method will be executing in the newly

formed thread at about the same time the

start() method returns in the first thread, as shown in

Figure 2.2.

Figure 2.2. Graphical representation of threaded method execution

Java Threads, 2nd edition

age 14

Here are the methods of the Thread class that we've discussed so far:

Thread()

Constructs a thread object using default values for all options.

void run()

The method that the newly created thread will execute. Developers should override this

method with the code they want the new thread to run; we'll show the default implementation

of the

run() method a little further on, but it is essentially an empty method.

void start()

Creates a new thread and executes the

run() method defined in this thread class.

To review, creating another thread of control is a two-step process. First, we must create the code that

executes in the new thread by overriding the

run() method in our subclass. Then we create the actual

subclassed object using its constructor (which calls the default constructor of the Thread class in this

case) and begin execution of its

run() method by calling the start() method of the subclass.

run() Versus main()

In essence, the run() method may be thought of as the main() method of the newly formed

thread: a new thread begins execution with the

run() method in the same way a program

begins execution with the

main() method.

While the

main() method receives its arguments from the argv parameter (which is

typically set from the command line), the newly created thread must receive its arguments

programmatically from the originating thread. Hence, parameters can be passed in via the

constructor, static instance variables, or any other technique designed by the developer.

2.1.1 Animate Applet

Let's see a more concrete example of creating a new thread. When you want to show an animation in

your web page, you do so by displaying a series of images (frames) with a time interval between the

frames. This use of a timer is one of the most common places in Java where a separate thread is

required: because there are no asynchronous signals in Java, you must set up a separate thread, have

the thread sleep for a period of time, and then have the thread tell the applet to paint the next frame.

An implementation of this timer follows:

import java.awt.*;

public class

TimerThread extends Thread {

Component comp; // Component that needs repainting

int timediff; // Time between repaints of the component

volatile boolean shouldRun; // Set to false to stop thread

public TimerThread(Component comp, int timediff) {

this.comp = comp;

this.timediff = timediff;

shouldRun = true;

}

public void run() {

while (shouldRun) {

try {

comp.repaint();

sleep(timediff);

} catch (Exception e) {}

}

Java Threads, 2nd edition

age 1

In this example, the TimerThread class, just like the OurClass class, inherits from the Thread class and

overrides the

run() method. Its constructor stores the component on which to call the repaint()

method and the requested time interval between the calls to the

repaint() method.

What we have not seen so far is the call to the

sleep() method:

static void sleep (long milliseconds)

Puts the currently executing thread to sleep for the specified number of milliseconds. This

method is static and may be accessed through the Thread class name.

static void sleep (long milliseconds, int nanoseconds)

Puts the currently executing thread to sleep for the specified number of milliseconds and

nanoseconds. This method is static and may be accessed through the Thread class name.

The

sleep() method is part of the Thread class, and it causes the current thread (the thread that

made the call to the

sleep() method) to pause for the specified amount of time in milliseconds. The

try statement in the code example is needed due to some of the exceptions that are thrown from the

sleep() method. We'll discuss these exceptions in Appendix B; for now, we'll just discard all

exceptions.

The easiest description of the task of the

sleep() method is that the caller actually sleeps for the

specified amount of time. This method is part of the Thread class because of how the method

accomplishes the task: the current (i.e., calling) thread is placed in a "blocked" state for the specified

amount of time, much like the state it would be in if the thread were waiting for I/O to occur. See

Appendix A for a discussion of the

volatile keyword.

sleep(long) and sleep(long, int)

The Thread class provides a version of the sleep() method that allows the developer to

specify the time in terms of nanoseconds. Unfortunately, most operating systems that

implement the Java virtual machine do not support a resolution as small as a nanosecond.

For those platforms, the method simply rounds the number of nanoseconds to the nearest

millisecond and calls the version of the

sleep() method that only specifies milliseconds. In

fact, most operating systems do not support a resolution of a single millisecond, so that the

milliseconds are in turn rounded up to the smallest resolution that the platform supports.

For the developer, we should note that support of nanoseconds may never be available in all

versions of the Java virtual machine. As a matter of policy, one should not design programs

that require support of nanoseconds (or even exact timing of milliseconds) in order to

function correctly.

To return to step 2 of the two-step process: let's take a look at the Animate applet that uses our

TimerThread class:

import java.applet.*;

import java.awt.*;

public class

Animate extends Applet {

int count, lastcount;

Image pictures[];

TimerThread timer;

public void init() {

lastcount = 10; count = 0;

pictures = new Image[10];

MediaTracker tracker = new MediaTracker(this);

for (int a = 0; a < lastcount; a++) {

pictures[a] = getImage (

getCodeBase(), new Integer(a).toString()+".jpeg");

tracker.addImage(pictures[a], 0);

}

tracker.checkAll(true);

}

剩余218页未读，继续阅读

c38776658

粉丝: 2
资源: 36

深入理解Java多线程：效率与安全性探索

Java Threads

Java Threads Third Edition.chm

linux实用脚本show-busy-java-threads

JAVA线程, 2Ed (Source).rar

Java线程（Java.Thread）（中英版）

Cracking The Coding Interview 5th Ed （高清版上卷）

Cracking The Coding Interview 5th Ed （高清版下卷）

java JDBC Socket

Java虚拟机性能监控与调优：保障应用稳定运行

Java算法性能分析：深入剖析算法性能，优化代码效率

最新资源