深入理解Java线程编程

需积分: 9 109 浏览量更新于2024-07-17 收藏 2.4MB PDF 举报

"SAMS Java Thread Programming - Paul Hyde - ISBN:0672315858" 在《SAMS Java Thread Programming》一书中，作者Paul Hyde深入浅出地介绍了如何利用Java线程来实现更高效、更快捷的程序设计。这本书面向的是有一定Java基础的专业开发者，特别是那些对多线程编程还不熟悉的读者。通过阅读这本书，读者能够显著提升自己的Java编程技能。书中的第一章节仅用了五页半的篇幅，快速地概述了线程的基本概念，随后立即进入实战阶段，通过丰富的实例讲解了从创建线程开始，直至线程间通信、线程组、线程池、线程与Swing组件的结合等关键主题。作者还分享了如何优雅地退出线程以及在什么情况下应该使用“SureStop”类来强制停止线程的见解，这对于避免线程管理中的常见问题至关重要。在“Part I Threads”部分，书中的第一章“Introduction to Threads”引出了线程的概念，让读者了解为何在Java中使用线程以及它们的基本工作原理。第二章“ASimpleTwo-ThreadExample”则通过一个简单的双线程示例，帮助读者直观地理解线程如何并发执行。第三章（未给出具体内容）可能继续深入讨论线程的创建、管理和同步等实际问题。对于希望深入理解Java并将其运用得淋漓尽致的开发者来说，这本书是一个值得投入时间学习的宝贵资源。它不仅提供了技术上的指导，还包含了作者多年经验的结晶，使得读者能够在实践中避免常见错误，提高代码的性能和可维护性。通过学习这本书，你将掌握如何有效地管理线程生命周期，避免死锁和竞态条件，以及如何优化多线程环境下的资源分配。此外，你还将了解到在特定情况下，单线程或多线程并不是最佳选择，从而能够根据实际需求做出明智的设计决策。《SAMS Java Thread Programming》是一本全面且实用的指南，对于想要提升Java多线程编程能力的开发者来说，它是不可或缺的参考书籍。

- 16 -

Figure 2.1: The class diagram for TwoThread.

Note

In this book, the notation used for class relationships is closely based on the

Unified Modeling Language (UML). Figure 2.2 shows an example of

relationships.

Different terms are used in this book to describe interclass relationships. All

the following phrases are true about the relationships depicted in Figure 2.2:

Figure 2.2: A sample class diagram showing generic relationships.

•

ClassA is the superclass of ClassB.

•

ClassB is a subclass of ClassA.

•

ClassB extends ClassA.

•

ClassB IS-A ClassA.

•

ClassB implements InterfaceF.

•

ClassB IS-A InterfaceF.

•

ClassB is the superclass of ClassC and ClassD.

•

ClassC is a subclass of both ClassB and ClassA.

•

ClassC IS-A ClassB, ClassC IS-A ClassA, and ClassC IS-A

InterfaceF.

•

ClassE contains (at least one reference to) ClassB.

•

ClassE HAS-A ClassB reference within it.

Overriding the run() Method

After extending Thread, the next step is to override the run() method because the

run() method of Thread does nothing:

public void run() { }

- 17 -

When a new thread is started, the entry point into the program is the run() method. The

first statement in run() will be the first statement executed by the new thread. Every

statement that the thread will execute is included in the run() method or is in other

methods invoked directly or indirectly by run(). The new thread is considered to be alive

from just before run() is called until just after run() returns, at which time the thread

dies. After a thread has died, it cannot be restarted.

In this chapter’s example, run() is overridden with code to loop for 10 iterations and

print the message New thread each time through:

public void run() {

for ( int i = 0; i < 10; i++ ) {

System.out.println(“New thread”);

}

After the for loop completes, the thread returns from the run() method and quietly

dies.

Spawning a New Thread

New threads are spawned from threads that are already running. First, a new Thread

instance must be constructed. In this example, a new TwoThread object will work just

fine because TwoThread IS-A Thread:

TwoThread tt = new TwoThread();

The next step is to kick off the execution of the thread by invoking the start() method

on the TwoThread object (start() is inherited from Thread):

tt.start();

A call to start() returns right away and does not wait for the other thread to begin

execution. In start(), the parent thread asynchronously signals through the JavaVM

that the other thread should be started as soon as it’s convenient for the thread

scheduler. At some unpredictable time in the very near future, the other thread will come

alive and invoke the run() method of the Thread object (or in this case, the overridden

run() method implemented in TwoThread). Meanwhile, the original thread is free to

continue executing the statements that follow the start() call.

The two threads run concurrently and independently. On a multi-processor machine,

these two threads may actually be running at the very same instant, each on its own

processor. This true simultaneity would also have to be supported in the port of the

JavaVM for that platform in order to exploit multiple processors.

A more likely case is that only a single processor is present. The JavaVM and the

operating system work together to schedule each thread for short, interleaved bursts of

processor usage. Each thread takes a turn running while the other threads are frozen,

waiting for their next turn on the processor. This context switching among threads

generally occurs very quickly and gives the illusion of truly simultaneous execution.

Caution

A newly created thread may start executing (enter the run() method) at

any time after start() is invoked. This means that the original thread

might be swapped out before any statement that follows start() is

executed.

- 18 -

If the original thread is executing this code

stmt1();

tt.start();

stmt2();

and the new thread has a run() method such as this

public void run() {

stmtA();

stmtB();

}

the order of actual statement execution in the processor might be stmt1(),

tt.start(), stmt2(), stmtA(), and stmtB(). Alternatively, it might be

stmt1(), tt.start(), stmtA(), stmtB(), and stmt2(). Perhaps, it

might be one of the other permutations!

Important to note is that although the order in which each thread will execute its

own statements is known and straightforward, the order in which the statements

will actually be run on the processor is indeterminate, and no particular order

should be counted on for program correctness.

Putting It All Together

Combining the preceding code and adding a second 10-iteration loop for the main thread

to run produces the complete code for TwoThread.java, shown in Listing 2.1.

Listing 2.1 TwoThread.java—The Complete Code for the TwoThread Example

1: public class TwoThread extends Thread {

2: public void run() {

3: for ( int i = 0; i < 10; i++ ) {

4: System.out.println(“New thread”);

5: }

6: }

8: public static void main(String[] args) {

9: TwoThread tt = new TwoThread();

10: tt.start();

11:

12: for ( int i = 0; i < 10; i++ ) {

13: System.out.println(“Main thread”);

14: }

15: }

16: }

First, note that the new class TwoThread directly extends Thread, so it IS-A Thread

and takes on all the capabilities of its superclass.

Application execution begins with the main thread, which is spawned by the JavaVM for

all applications at startup, entering the main() method (line 8). It proceeds to create a

new TwoThread instance (line 9). Next, it spawns a new thread of execution by invoking

the start() method (line 10). This new thread will begin its execution by invoking the

run() method (line 2) of TwoThread.

- 19 -

At this point, two threads are ready to run, and the thread scheduler runs each thread for

short periods, alternating between them. If this switching back and forth is fast enough,

they appear to be running simultaneously.

After the main thread spawns the new thread, the main thread proceeds into its loop

(lines 12–14) and prints Main thread to the console 10 times. When it is done with the

loop, it falls through and returns from main(). The main thread dies when it returns from

main().

At approximately the same time, the new thread enters the run() method (line 2),

proceeds into its loop (lines 3–5), and prints New thread to the console 10 times. When

it is done with the loop, it falls through and returns from run(). The new thread dies

when it returns from run().

When both threads have completed their work and died, the JavaVM shuts down and the

application is done.

Listing 2.2 shows possible output from running this application (your output might differ).

During this run of the application, the messages from the two threads happened to be

perfectly interleaved, starting with the message from the main thread. There is no

guarantee that this output would be the same if the application was run again. Thread

scheduling is nondeterministic and depends on many factors, including what else is

currently running in the operating system. The thread scheduler makes what seem to be

random decisions about how long each thread should be allowed to run between context

switches. The only thing that can be counted on from running this application is that each

message will print exactly 10 times, regardless of the order of the messages.

Listing 2.2 Possible Output from a Run of TwoThread.java

Main thread

New thread

Main thread

New thread

Main thread

New thread

Main thread

New thread

Main thread

New thread

Main thread

New thread

Main thread

New thread

Main thread

New thread

Main thread

New thread

Main thread

New thread

Summary

This chapter explores how to create a new thread by performing these tasks:

- 20 -

•

Subclassing Thread

•

Overriding the run() method of Thread to specify the statements to be executed by the

new thread

•

Creating a new instance of this subclass of Thread

•

Spawning a new thread by invoking start() on this instance

That’s all there is to getting a second thread up and running in Java! The following chapters

explore the complexities of threads and the coordination of the intercommunication that

usually must occur among them.

Chapter 3: Creating and Starting a Thread

Overview

This chapter explores more of the Thread API, including getting a handle on the currently

executing thread, thread naming, some of the different constructors, and putting a thread to

sleep for awhile. You will use these features to enhance the TwoThread example from

Chapter 2, “A Simple Two-Thread Example.”

Using Thread.currentThread()

At times, it’s useful to know which of the threads currently running in the Java Virtual

Machine (JavaVM) is executing a segment of code. In multithreaded programming, more

than one thread may enter a method and execute the statements within it.

In the TwoThread example from Chapter 2, two threads execute the code in the

println() method of the PrintStream object referred to by the System.out

reference:

System.out.println(“Main thread”);

System.out.println(“New thread”);

This one PrintStream object is set up by the JavaVM during initialization for use by

any class at any time in a Java program through the System.out reference. Any

running thread can invoke the println() method. In this case, the println() method

does not care which thread invoked it; it simply takes the String passed in and prints it.

In the Thread API, you can use the static method

public static native Thread currentThread()

to determine which thread is executing a segment of code. You can use this

Creating and Starting a Thread

Note

Many of the methods in Thread are listed with some of the following

modifiers: native, final, static, and synchronized. As a quick review,

native methods are implemented in non-Java code (typically C or C++ in the

JDK). Methods declared to be final may not be overridden in a subclass.

When a method is static, it does not pertain to a particular instance of the

class, but operates at the class level. The f3 synchronized modifier

guarantees that no more than one thread is allowed to execute the statements

剩余374页未读，继续阅读

caofeng891102

粉丝: 171

深入理解Java线程编程

Sams教你21天学会Java™6

21天掌握Java 6：Sams教学指南

Linux 编程全面解密：SAMS 第二版

SAMS Java Thread Programming.zip

SAMS Java Thread Programming.pdf

Java Thread Programming (Sams) java线程编程（含code）

Java Thread Programming

Sams Unix Shell Programming

SAMS Linux Socket Programming by Example

Black Art of Java Game Programming (SAMS).chm

最新资源