鸿 网 互 联 www.68idc.cn

当前位置 : 服务器租用 > 网站制作教程 > JSP > >

Java语言导学笔记Chapter8Thread

来源:互联网 作者:佚名 时间:2016-06-19 10:17
8.1 什么是线程 def: 线程是程序内的一个单一的顺序控制流程 作为一个顺序的控制流程,线程必须在运行它的程序中占用一些资源。例如,线程必须有它自己的执行堆栈和程序计数器。在线程内运行的代码只在此上下文中工作。其他一些文章将线程称为执行上下文(exe

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

                   <APPLET CODE= "Clock.class" WIDTH=150 HEIGHT=35></APPLET>

         </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,线程处于”可运行“或者”不可运行“。


网友评论
<