JAVA 线程编程 ----两个线程程序

[b][size=medium]Java的内置线程支持[/size][/b]

关于Java好的方面是它有内置的写多线程的支持。Java的设计者知道多线程编程的价值，所以聪明决定在Java的核心部分就决定直接支持线程。在第7章“并发存取对象和变量”就阐述了在Java语言中，synchronized关键字如何被用来锁住对象和类来控制并发存取数据。Thread和ThreadGroup类就在java.lang包的核心API中。通过wait( ) notify( ) 方法的支持，Java中所有类的父类Object具有线程间通信的能力。即使当前操作系统不支持线程概念，一个写好的JVM也可以模拟多线程环境。在Java中，线程的支持不是事后的，而是从一开始设计时就包括进来的。


[size=medium][b]第2章：一个简单的两个线程例子[/b][/size]
[b]概述[/b]

这章展示了创建并在一个小的Java应用中运行线程是如何简单。第一个线程总是在由JVM创建的“main”线程，该线程开始运行程序。该主线程然后创建第二个线程。每个线程将在控制台打印各自信息，以此来证明他们好像以同步方式运行。

创建一个线程的步骤如下：

[list]
[*]继承java.lang.Thread类
[*]在继承Thread的子类中重写run( )方法；
[*]创建这个新类的实例
[*]调用该实例的start( )方法
[/list]

[size=medium]继承java.lang.thread类[/size]

在JVM中每个线程与java.lang.Thread类的一个实例相关联。这些Thread对象作为与底层操作系统线程交互的接口。通过该类中的方法，可以对线程进行开始，停止，中断，命名、设置优先级和查询有关线程当前状态等操作。

[b]注意：{/b]有两种方式可创建一个允许线程运行于其中的类。一种方式是继承Thread类；另一种是继承任意类并且实现Runnable接口。为了便于说明，继承Thread类是最简单的方法，本书开始就是用该方法。在实际中，实现Runnable接口可能工作地更好些。

在这个例子中，创建新线程的第一步是继承java.lang.Thread类：

public class TwoThread extends Thread {	
	    // ...	
	}

TwoThread子类是一个（IS-A） Thread，继承了父类的protected 和public成员。TwoThread除了从父类中继承的其他行为之外，它还可以对线程进行开始、停止、中断、命名、设置优先级以及查询线程当前状态等操作。
[size=medium]
重写run()方法[/size]
继承Thread类之后，下一步就是重写run()方法，因为Thread类中方法什么也没做：
Public void run() { }

当一个新线程开始运行，进入该线程的入口就是run()方法。run()中的第一条语句就是新线程执行的第一条语句。线程执行的每条语句都包含在run()方法中或包含在被run()方法直接或间接调用的其他方法中。从run()被调用之前到run()返回，新线程被认为是活着的。run()返回之后，线程就死掉了。当一个线程死了之后不能重新开始。
在本章的例子中，run()方法被重写为迭代10次并且每次打印New thread信息：

public void run() {	
	    for ( int i = 0; i < 10; i++ ) {	
	        System.out.println(“New thread”);
	    }	
	}

循环完成之后，线程从run()方法返回，然后安静死掉。

[size=medium][b]创建一个新线程 Spawning a New Thread[/b][/size]
新线程从已经运行的线程来创建。首先，构造一个新Thread实例。在此例中，一个新TwoThread对象将正好，因为TwoThread IS-A Thread：
TwoThread tt = new TwoThread();

下一步是调用start()方法准备开始执行线程（start()从Thread继承而来）：
tt.start();

start()调用后立即返回，不需要等待其他线程开始执行。在start()中，父线程异步地从JVM中给线程调度程序发出信号，告诉它只要它方便，其他线程可以开始执行了。在未来某个不可预期的时间里，其他线程将被激活，并调用Thread对象的run()方法（在该例中是指TwoThread中实现的重写方法run()）。与此同时，原来的线程继续执行start()方法后面的语句。

两个线程并发、独立地运行。在一个多处理器的机器上，这两个线程可能在同一时刻真正都在运行，各自运行在自己的处理器上。

一个更常见的情况是只有一个处理器，JVM和OS共同工作在短时间调度每个线程。当其他线程被冻结，等待处理器的下一次机会时，每个线程就得到一次运行的机会。这种在线程之间的上下文切换是非常快的，给人一种同时执行的假象。

提示：一个新创建的线程可能在start()被调用之后的任何时间开始执行（进入run()方法）。这意味着start()方法之后的任何语句被执行之前，原来线程都可能被换出（swapped out）。
假如原来的线程正在执行下面的代码：
stmt1();
tt.start();


新线程有一个run()方法如下：

public void run() {	
	    stmtA();
	    stmtB();
	}
	stmt2();

处理器中实际执行的语句顺序可能是stmt1(), tt.start(), stmt2(), stmtA(), and stmtB()。也可能是：stmt1(), tt.start(), stmtA(), stmtB(), and stmt2().也许还可能是另外一种顺序。

重要的是要记住：尽管每个线程将执行各自语句的顺序是已知和简单的，但是实际运行在处理器上的语句却是不确定的。对于程序的正确性而言，没有一种特殊的顺序可以依赖。

把所有放在一起

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:     }	
	7:	
	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: }

第一次运行的结果：
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


第二次运行的结果：

Main Thread
Main Thread
Main Thread
Main Thread
Main Thread
Main Thread
Main Thread
Main Thread
Main Thread
Main Thread
New Thread
New Thread
New Thread
New Thread
New Thread
New Thread
New Thread
New Thread
New Thread
New Thread
从以上结果可以看出来，每次运行的结果都不一样，你的机器上也可能不一样。