Java语言导学笔记 Chapter 8 Thread

8.1 什么是线程

def: 线程是程序内的一个单一的顺序控制流程

作为一个顺序的控制流程，线程必须在运行它的程序中占用一些资源。例如，线程必须有它自己的执行堆栈和程序计数器。在线程内运行的代码只在此上下文中工作。其他一些文章将线程称为执行上下文(execution context)。

如果你的程序必须反复执行一个任务，那么应该考虑使用java.util.Timer类。对于在一段程序后执行另一个任务，Timer类也很有用。

如果你正在编写一个具有图形的用户界面（GUI）的程序，那么应该使用javax.swing.Timer类。

对线程的基本支持由java.lang.Thread类提供。它提供了一个线程API并提供了线程的所有共有行为。这些行为包括启动、睡眠、运行、放弃和给予优先级。要使用Thread类实现线程，需要为它提供一个run方法，run方法实际执行线程的任务。

8.2 使用Timer和TimerTask类

Reminder.java这个例子使用计时器在一段延迟时间之后执行一个任务。

import java.util.Timer;

import java.util.TimerTask;

public class Reminder{

Timer timer;

public Reminder(int seconds){

timer = new Timer();

timer.schedule(new RemindTask(), seconds*1000);

}

class RemindTask extends TimerTask{

public void run(){

System.out.println("Time's up!");

timer.cancel(); //Terminate the timer thread

}

public static void main(String args[]){

new Reminder(5);

System.out.println("Task scheduled.");

}

实现和调度有计时器线程执行的任务的基本部分。

1、实现一个定制的TimerTask子类。run方法包含执行任务的代码。

2、通过实例化Timer类创建一个线程。

3、实例化一个计时器任务对象(new RenmindTask())。

4、调度这个计时器任务的执行。本例使用schedule方法。

让一个任务在特定时间执行：

import java.util.Timer;

import java.util.TimerTask;

import java.util.Calendar;

import java.util.Date;

public class Reminder{

Timer timer;

public Reminder(int seconds){

timer = new Timer();

timer.schedule(new ReminderTask(), seconds*1000);

}

public Reminder(){

Calendar calendar = Calendar.getInstance();

calendar.set(Calendar.HOUR_OF_DAY, 11);

calendar.set(Calendar.MINUTE, 9);

calendar.set(Calendar.SECOND, 0);

Date time = calendar.getTime();

timer = new Timer();

timer.schedule(new RemindTask2(), time);

}

class ReminderTask extends TimerTask{

public void run(){

System.out.println("Time's up!");

timer.cancel(); //Terminate the timer thread

}

class RemindTask2 extends TimerTask{

public void run(){

System.out.println("Time's up! Ring on.");

timer.cancel(); //Terminate the timer thread

}

public static void main(String args[]){

new Reminder(5);

new Reminder();

System.out.println("Task scheduled.");

}

在默认情况下，只要程序的计时器线程在运行，程序就一直运行。有四种方式可以终止计时器线程。

1、在计时器线程上调用cancel方法。

2、使计时器成为“守护线程”（deamon），办法是这样创建计时器: new Timer(true) 。如果程序中仅剩下守护线程，那么程序退出。

3、在计时器的被调度的所有任务都完成后，删除所有对Timer对象的引用。最后计时器的线程将退出。

4、调用System.exit方法，使整个程序退出。

重复执行任务：

import java.util.Timer;

import java.util.TimerTask;

import java.awt.Toolkit;

/**

* Schedule a task that executes once every second.

public class AnnoyingBeep {

Toolkit toolkit;

Timer timer;

public AnnoyingBeep() {

toolkit = Toolkit.getDefaultToolkit();

timer = new Timer();

timer.schedule(new RemindTask(),

0, //initial delay

1*1000); //subsequent rate

}

class RemindTask extends TimerTask {

int numWarningBeeps = 3;

public void run(){

if (numWarningBeeps > 0) {

toolkit.beep();

System.out.println("Beep!");

numWarningBeeps--;

} else {

toolkit.beep();

System.out.println("Time's up!");

//timer.cancel(); //Not necessary because we call System.exit

System.exit(0); //Stops the AWT thread (and everything else)

}

public static void main(String args[]) {

System.out.println("About to schedule task.");

new AnnoyingBeep();

System.out.println("Task scheduled.");

}

AnnoyingBeep程序使用schedule方法的三参数版本，指定它的任务应该马上开始执行，并且每1秒执行一次。下面是所有可用来调度任务反复执行的方法:

schedule(TimerTask task, long delay, long period)

schedule(TimerTask task, Date time, long period)

scheduleAtFixedRate(TimerTask task, long delay, long period)

scheduleAtFixedRate(TimerTask task, Date firstTime, long period)

在调度任务反复执行时，如果执行的平滑性很重要，那么应该使用schedule方法之一，如果一次蜂鸣声因为某种原因推迟了，那么后续的所有的蜂鸣声将相应延迟；如果时间的同步更重要，那么应该使用scheduleAtFixedRate方法之一，如果想让程序在第一次蜂鸣后正好3秒退出，，如果一次蜂鸣声因为某种原因延迟了，那么两次蜂鸣的时间可能较近，小于1秒。

8.3 定制线程的run方法

有两种技术可以为线程提供run方法：

1、对Thread类进行子类化并覆盖run方法

2、实现Runnable接口

对Thread类进行子类化并覆盖run方法

Thread类本身是一个Runnable对象。

public class SimpleThread extends Thread{

public SimpleThread(String str){

super(str);

}

public void run(){

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

System.out.println(i + " " + getName());

try{

sleep((int)(Math.random()*1000));

}catch(InterruptedException e){}

}

System.out.println("Done! " + getName());

}

第一个方法是构造器，调用超类构造器设置线程名称。

public class TwoThreadDemo{

public static void main(String[] args){

new SimpleThread("Jamaica").start();

new SimpleThread("Fiji").start();

}

实现Runnable接口

import java.awt.Graphics;

import java.util.*;

import java.text.DateFormat;

import java.applet.Applet;

public class Clock extends Applet implements Runnable {

private Thread clockThread = null;

public void start(){

if(clockThread == null){

clockThread = new Thread(this, "Clock");

clockThread.start();

}

public void run(){

Thread myThread = Thread.currentThread();

while(clockThread == myThread){

repaint();

try{

Thread.sleep(1000);

}catch(InterruptedException e){

//the VM doesn't want us to sleep anymore;

//so get back to work

}

public void paint(Graphics g){

//get the time and convert it to a date

Calendar cal = Calendar.getInstance();

Date date = cal.getTime();

//format it and display it

DateFormat dateFormatter = DateFormat.getTimeInstance();

g.drawString(dateFormatter.format(date), 5, 10);

}

//overrides Applet's stop method, not Thread's

public void stop(){

clockThread = null;

}

<html>

<head>

<title>Clock</title>

</head>

<body>

I'm now listening to OuRuoLa

</body>

</html>

这个Clock applet 显示当前时间并且每1秒更新一次。问题是会间接的闪烁，或许和CPU的工作状态有关。用appletviewer Clock.html查看。

Clock applet的run方法进行循环，知道浏览器要求他停止。在循环的每次迭代期间，时钟重新绘制它的显示。

如果你的泪必须子类化另一个类，那么应该使用Runnable接口。

8.4 线程的生存周期

1、创建线程

clockThread = new Thread(this, "Clock"); 执行后Clock applet处于”新线程”状态。此时线程仅仅是一个空的Thread对象，这时只能启动线程，调用除start方法外的任何方法都是无意义的，而且会导致IllegalThreadStateException。实际上，只要在线程上调用一个方法，而此线程的状态不允许此方法调用，那么运行时系统都会抛出IllegalThreadStateException。

2、启动线程

clockThread.start(); start方法分配线程所需的系统资源，调度线程运行，并调用线程的run方法。

start方法返回后，线程处于“正在运行”状态。实际情况要更复杂。如果计算机只有一个处理器，这样就不可能同时运行所有”正在运行“的线程。Java运行时环境必须实现一个调度方案，以便在所有”正在运行“的线程分享处理器。所以在任何给定时刻，”正在运行”的线程可能正在等待轮到它使用CPU。

public void run(){

Thread myThread = Thread.currentThread();

while(clockThread == myThread){

repaint();

try{

Thread.sleep(1000);

}catch(InterruptedException e){

//the VM doesn't want us to sleep anymore;

//so get back to work

}

Clock的run方法在条件clockThread == myThread成立时一直循环。它使线程和applet平缓地退出。在循环中，applet重新绘制本身，然后让线程睡眠1000毫秒。

1、使线程不可运行

当以下事件之一发生时，线程变成“不可运行”状态：

它的sleep方法被调用；

线程调用wait方法等待某个条件得到满足；

线程因I/O而阻塞。

对于每个进入“不可运行“状态的入口，有一个特定的不同出口将线程返回到”可运行“状态。

如果一个线程已经进入睡眠状态，那么必须经过指定的睡眠时间（毫秒数）；

如果一个线程正在等待某个条件，那么另一个对象必须通过调用notify或notifyAll告知正在等待的线程条件发生了改变；

如果一个线程因I/O而阻塞，那么I/O必须完成。

2、停止线程

自然消亡；

while(clockThread == myThread)这个条件表示，当前执行的线程不等于clockThread时循环退出。当你离开页面时，运行此applet的应用程序调用applet的stop方法。然后，这个方法设置clockThread为null，由此让主循环终止run方法。如果重新访问这个页面，那么再次调用start方法，时钟在一个新线程中再次启动。即使停止和启动applet的时间快于循环一次的迭代，clockThread线程也将不同于myThread，循环将终止。

3、 isAlive方法

返回false，线程处于”新线程“状态，或者已经消亡。返回true，线程处于”可运行“或者”不可运行“。